/*+----------+--------------------------------------------------+---------+
  | 11/02/97 |                                                  | Ver 1.0 |
  +----------+                   COMPTA.H                       +---------+
  |   RAO    |                                                  |  EIC |
  +----------+--------------------------------------------------+---------+
  |                                                                       |
  |    Ce fichier déclare les diverses types et fonctions de comptabilité |
  | pour les modules REV'A.O. interfacés.                                 |
  +-----------------------------------------------------------------------+*/
  #ifdef __BCPLUSPLUS__
    /* Utilisation par un assistant 32 bits, Compta32.dll ou Compta.bpl */
  #ifdef _COMPTA_BPL
    #define PACKAGE_COMPTA __declspec( dllexport)
  #else
    #define PACKAGE_COMPTA __declspec( dllimport)
  #endif
  # include <EICDos.h>
  # include <map>
    typedef dateDOS date;
  #else
     /* Utilisation par un assistant 16 bits */
  #  include <HyperLnk.h> /* Pour récup d'un compte à l'écran */
  #  include <EICFct.h>
  #  include <Dates.h>
  #endif

 #ifndef _COMPTA_H
  #define _COMPTA_H

// Codes des cycles
enum CODE_CYCLE {
  CYC_CAPITAUX = 0, // Capitaux permanents
  CYC_IMMO,         // Immobilisations
  CYC_STOCK,        // Stocks / Travaux en cours
  CYC_FOURN,        // Fournisseurs / Achats / Charges externes
  CYC_CLIENTS,      // Clients / Ventes
  CYC_PERSONNEL,    // Personnel / Organismes Sociaux
  CYC_ETAT,         // Etat
  CYC_GROUPE,       // Groupe et Associés
  CYC_TRESORERIE,   // Trésorerie
  CYC_AUTRES_CPTS,  // Autres Comptes
  CYC_EX_CRITIQUE,  // Examen Critique
  CYC_ETATS_FI,     // Etats financiers

  CYC_FIRST = CYC_CAPITAUX,
  CYC_LAST  = CYC_ETATS_FI,
  CYC_NUL   = 0xFF,
  CYC_NB_CYCLES = 13,       //A mettre à jour si on change le nombre de cycle
  CYC_NB_CYCLES_IMP = 10,
 };

  #ifndef _AUTONOME



  /*** Types possible d'un journal ***/
  #define CPTA_JNAL_A_NOUVEAU  0
  #define CPTA_JNAL_ACHATS     1
  #define CPTA_JNAL_VENTES     2
  #define CPTA_JNAL_TRESO      3
  #define CPTA_JNAL_OD         4
  #define CPTA_JNAL_INVENTAIRE 5
  #define CPTA_JNAL_BALANCE    6
  #define CPTA_JNAL_LAST       CPTA_JNAL_BALANCE
  #define CPTA_JNAL_CADOR_LAST CPTA_JNAL_OD


  /**********************/
  /*** Plan Comptable ***/
  /**********************/
  #ifndef __BCPLUSPLUS__
   /*** Identifiant des compta auxilliaires (1er caractère du n° de compte) ***/
   /*** Les comptes généraux commencent toujours par un digit entre '1' et '8' ***/
   #define CPTA_CPT_CLIENT      'C'
   #define CPTA_CPT_FOURNISSEUR 'F'

  #endif
  #pragma pack(2)
  typedef struct tagCPTA_PC {
    char           szCompte[ 13 + 1];   /* N° de compte */
    char           szIntitule[ 35 + 1]; /* Intitulé du compte */
    double         dSoldeN;             /* Soldes */
    double         dSoldeNm1;
    double         dSoldeNm2;
    double         dSoldeNm3;
    double         dSoldeNm4;
    double         dDebitN;             /* Débits */
    double         dDebitNm1;
    double         dDebitNm2;
    double         dDebitNm3;
    double         dDebitNm4;
    double         dCreditN;            /* Crédits */
    double         dCreditNm1;
    double         dCreditNm2;
    double         dCreditNm3;
    double         dCreditNm4;
    unsigned short bIsInactif;          /* != 0 si compte inactif (non mouvementé depuis N-4) */
    unsigned short eCodeCycle;          /* Une valeur CYC_* */
   } CPTA_PC;
  #pragma pack()


  /******************/
  /*** Historique ***/
  /******************/
  /*** Structure de données d'un module RAO dans l'historique ***/
  #pragma pack(1)                  /*+---+---+----------------------------------+*/
  typedef union tagCPTA_HIRAODATA { /*|Pos|Len|           Description            |*/
      struct {                      /*|---+---+----------------------------------+*/
        char sTVTxTVA[ 4];          /*|000|  4| TV : Taux de TVA de l'écriture   |*/
        char sTVCodeTVA[ 2];        /*|004|  2| TV : Code TVA de l'écriture      |*/
        char sFiller[ 6];           /*|006|  6| ??                               |*/
      } TVA;
      struct {                      /*| Comptes 455                                     |*/
        char sDateValeur[ 6];       /*|000|  6| IC : Date de Valeur Intérêts CC         |*/
        char sCodeMvt[ 6];          /*|006|  6| IC : Code mouvement (Apport, prélèv...) |*/
      } ICC;                        /*+---+---+-----------------------------------------+*/
      struct {                      /*| Comptes 6                                       |*/
        char sDateDebPer[ 6];       /*|000|  6| CH : date de debut de periode           |*/
        char sDateFinPer[ 6];       /*|006|  6| CH : date de fin de periode             |*/
      } CH;                         /*+---+---+-----------------------------------------+*/
      struct {                      /*| Comptes 455                                     |*/
        char sFiller[ 6];           /*|000|  6| ??                                      |*/
        char sCodeMvt[ 6];          /*|006|  6| AN : Code mouvement (Apport, prélèv...) |*/
      } AN;                         /*+---+---+-----------------------------------------+*/
    } CPTA_HIRAODATA;               /*|Tot| 12|*/
  #pragma pack()                    /*+---+---+*/

  #pragma pack(2)
  typedef struct tagCPTA_HI {
    char           szCompte[ 13 + 1];     /* N° de compte de la ligne d'écriture */
    unsigned short _bRAODataModified;     /* Usage interne */
    long           _lOffset;              /*   "      "    */
    long           lIDForUpdate;          /* A transmettre à CptaHIUpdateRAOData()/CptaHIGetRAOData() seulement */
    unsigned short eTypeJournal;          /* Type jnal ds lequel l'écriture a été passée CPTA_JNAL_* */
    char           szCodeJournal[ 5 + 1]; /* Code du jnal ds lequel l'écriture a été passée */
    unsigned short bIsLettree;            /* != 0 si ligne d'écriture lettrée */
    date           dateImputation;        /* Date d'imputation de l'écriture */
    unsigned short bIsDebiteur;           /* != 0 si le montant de l'opération est débiteur */
    double         dMontant;              /* Montant de l'opération */
    char           szNoPiece[ 15 + 1];    /* N° de pièce            */
    char           szLibelle[ 35 + 1];    /* Libellé de l'opération */
    CPTA_HIRAODATA RAOModuleData;         /* Données privées de modules ([' '] si vide) */
    char           szRAOPrefixeModule[ 2 + 1]; /* Préfixe du module émetteur de la ligne */
    char           cRAOIDEcriture;             /* ID - interne au module émetteur - de l'écriture */
    unsigned long  IDEcriture;            /* ID de l'écriture */
    date           dateOrigine;           /* Date d'imputation d'origine de l'écriture */
    char           szCodeJournalOrigine[ 5 + 1]; /* Code du jnal d'origine ds lequel l'écriture a été passée */
    char           szLettrage[ 4 + 1]; /* Lettrage*/
    date           dateEcheance;           /* Date d'échéance de l'écriture */
   } CPTA_HI;
  #pragma pack()

  /* Fonction d'énumération du HI */
  typedef void (FAR _cdecl* CPTA_HI_CALLBACK)(const CPTA_HI FAR* lpchi, long lUserData);

  //*******************************************//
   // Définition des identificateurs d'exercice //
   //*******************************************//
   #define IDEXERCICE_INCONNU 999
   #define IDEXERCICE_COURANT 100 // La signification de "exercice courant" est dynamique
   #define IDEXERCICE_Np1       1
   #define IDEXERCICE_N         0
   #define IDEXERCICE_Nm1      -1
   #define IDEXERCICE_Nm2      -2
   #define IDEXERCICE_Nm3      -3
   #define IDEXERCICE_Nm4      -4

   /**************************************************/
   /*** Fonctions de gestion des numéros de compte ***/
   /**************************************************/
#endif /* #ifndef _AUTONOME */
  #ifndef __BCPLUSPLUS__
    extern char* PASCAL CptaFormateCpte( char *szNoCpt, int nLen);
  #endif
#ifndef _AUTONOME
  #ifndef __BCPLUSPLUS__
    /*** Récupération d'un n° de compte ***/
    extern void  PASCAL CptaBeginFreeNoCpt();
    extern void  PASCAL CptaEndFreeNoCpt();
    extern int   PASCAL CptaRecNoCpt( HSChamp hsNoCpt,
                                      char    szNoCpt[ 13 + 1]); /* retourne TRUE si n° cpt valide */
    extern int   PASCAL CptaIsCompteRacineDe( const char* pcszCompte, const char* pcszRacineEIC);

    extern char* PASCAL CptaGetCompteSelectionne( char szNoCpt[ 13 + 1]);
    extern int   PASCAL CptaPresente();
    extern short PASCAL PcContientAuMoinsUnCompte();


   /****************************************************/
   /*** Fonctions de gestion des fichiers comptables ***/
   /****************************************************/
   /*** Actions à l'ouverture d'un fichier ***/
   #define CPTA_ACT_ECRITURE       0x0002 /* Gestion du fichier des écritures (interne à la lib) */
   #define CPTA_ACT_HISTORIQUE     0x0004 /* Gestion du fichier historique */
   #define CPTA_ACT_PLAN_COMPTABLE 0x0008 /* Gestion du fichier plan-comptable */
   #define CPTA_ACT_RW             0x0010 /* Accès en Lecture/Ecriture (sinon Lecture seule) */
   #define CPTA_ACT_INVALIDATE     0x0020 /* Accès pour invalider/annuler (sinon valider) */

   #define CPTA_ACT_BARRE_MASK              0xF800 /* Usage interne : Masque des bits de gestion de la barre */
   #define CPTA_ACT_DEFAULT                 0x0000 /* Gestion par défaut de la barre */
   #define CPTA_ACT_NO_MSG_BARRE            0x0800 /* Pas de progression (ni d'initialisation) de la barre */
   #define CPTA_ACT_NO_PROGRESS_BARRE       0x1000 /* Pas de progression (ni d'initialisation) de la barre */
   #define CPTA_ACT_ONLY_BARRE_PLUS_ON_CALL 0x3000 /* Ne fait qu'incrémenter la barre de 1 après l'opération (inclut obligatoirement NO_PROGRESS) */
   #define CPTA_ACT_NO_OPEN_BARRE           0x4000 /* Ne pas ouvrir et fermer la barre */
   #define CPTA_ACT_NO_CLOSE_BARRE          0x8000 /* Laisser barre ouverte après CloseEcriture */
   #define CPTA_ACT_NO_BARRE                (CPTA_ACT_NO_OPEN_BARRE | CPTA_ACT_NO_MSG_BARRE | CPTA_ACT_NO_PROGRESS_BARRE | CPTA_ACT_NO_CLOSE_BARRE)

   /*** Fonctions d'ouverture/fermeture des fichiers ***/
   extern void PASCAL _CptaOpen(unsigned fAction); /* CPTA_ACT_* combinés */
   extern void PASCAL _CptaClose();

   /*** Fonctions de gestion des actions de la barre ***/
   extern unsigned PASCAL CptaPushNoBarreAction();
   extern void     PASCAL CptaPopNoBarreAction(unsigned uOldBarreAction);


   /********************************************/
   /*** Fonctions de gestion de l'historique ***/
   /********************************************/
   /*** Fonctionnalités ***/
   extern void PASCAL _CptaHIOpen(unsigned    fAction,        /* CPTA_* combinés */
                                   const date* pcDateDebImput, /* NULL = Date Deb Exercice */
                                   const date* pcDateFinImput);/* NULL = Date Situation */

   #define CptaHIOpenForRead(fActionBarre)     _CptaHIOpen(CPTA_ACT_HISTORIQUE               | (fActionBarre), NULL, NULL)
   #define CptaHIOpenForMAJ(fActionBarre)      _CptaHIOpen(CPTA_ACT_HISTORIQUE | CPTA_ACT_RW | (fActionBarre), NULL, NULL)
   #define CptaHIOpenMaintenance(fActionBarre) _CptaHIOpen(CPTA_ACT_HISTORIQUE | CPTA_ACT_RW | (fActionBarre), NULL, NULL)
   #define CptaHIClose()                        _CptaClose()

    extern void PASCAL CptaEnumHIComptesDansRacine(CPTA_HI_CALLBACK lpfnCptaHIEnum,
                                                    const char*      pcszRacine,
                                                    long             lUserData);
    extern void PASCAL CptaEnumHIDetailCompte(CPTA_HI_CALLBACK lpfnCptaHIEnum,
                                               const char*      pcszCompte,
                                               long             lUserData);

   extern int  PASCAL CptaHIGetFirstOfRacine(CPTA_HI* phi, const char cszRacine[ 13 + 1] /* "" = 1er cpt du HI */);
   extern int  PASCAL CptaHIGetNextOfRacine(CPTA_HI* phi);
   extern void PASCAL CptaHIUpdateRAOData(long lIDForUpdate, const CPTA_HIRAODATA* pcRAOModuleData);
   extern void PASCAL CptaHIGetRAOData(long lIDForUpdate, CPTA_HIRAODATA* pRAOModuleData);


   /**********************************************/
   /*** Fonctions de gestion du plan comptable ***/
   /**********************************************/
    /*** Types ***/
   /* Fonction d'énumération du PC */
    typedef void (FAR _cdecl* CPTA_PC_CALLBACK)(const CPTA_PC FAR* lpcpc, long lUserData);

   /*** Fonctionnalités ***/
   #define CptaPCOpenForRead(fActionBarre) _CptaOpen(CPTA_ACT_PLAN_COMPTABLE | (fActionBarre))
   #define CptaPCClose()                    _CptaClose()

    extern void PASCAL CptaEnumPCComptesDansRacine(CPTA_PC_CALLBACK lpfnCptaPCEnum,
                                                    const char*      pcszRacine, /* "" = Tous les comptes */
                                                    long             lUserData);

   extern int PASCAL CptaPCGetEQ(CPTA_PC* ppc, const char cszCompte[ 13 + 1]); /* != 0 si trouvé */

   extern int PASCAL CptaPCCreerCompteDlg( HWND       h,
                                           char       szCompteCree[ 13 + 1],
                                           char       szIntituleCree[ 35 + 1],
                                           const char cszRacineACreer[ 13 + 1] /* = NULL */); /* TRUE si créé */


   /*****************************************************/
   /*** Fonctions de gestion des écritures comptables ***/
   /*****************************************************/
   /*** Types d'éritures comptables ***/
   #define CPTAECR_COURANTE                0x0001
   #define CPTAECR_INVENTAIRE              0x0002
   #define CPTAECR_A_CONTREPASSER          0x0004
   #define CPTAECR_A_NE_PAS_CONTREPASSER   0x0008

   #define CPTAECR_VALIDATE                0x0000 /* Pour valider une ecr. en compta */
   #define CPTAECR_CANCEL                  0x0010 /* Pour annuler une ecr. dans la compta */
   #define CPTAECR_NO_CONFIRM_CANCEL       0x0020 /* Ne confirme pas l'annulation de l'écr. en comtpa */

   /*** Gestion du fichier des écritures comptables ***/
   extern int PASCAL _CptaCloseAndSendEcriture(unsigned short fClose); /* TRUE si Ecriture envoyée */

   extern void PASCAL _CptaOpenEcriture(unsigned short fEcriture,         /* CPTAECR_*  */
                                         long           lNbPutToDo,        /* Nb de lignes à "puter" pour c't'écriture (>= 2) */
                                         char           cIDEcriture,       /* ID écriture perso au module */
                                         const date*    pcdateImputation); /* NULL = date Situation */
   extern int PASCAL _CptaCancelEcriture(unsigned short fEcriture,         /* CPTAECR_*  */
                                          char           cIDEcriture,       /* ID écriture perso au module */
                                          const date*    pcdateImputation); /* NULL = date Situation *//* TRUE si bien annulée */

   extern void PASCAL CptaPutEcriture(const char*           pcszCompteImputation,
                                       const char*           pcszLibelleEcriture,
                                       unsigned short        bIsDebiteur,          /* != 0 si montant opération débiteur */
                                       double                dMontant,             /* != 0.0 */
                                       const CPTA_HIRAODATA* pcRAOData);           /* = NULL */


   #define CptaOpenEcriture(fEcr, lNbPutToDo, cIDEcr) _CptaOpenEcriture((fEcr), (lNbPutToDo), (cIDEcr), NULL)
   #define CptaCloseEcriture()                         _CptaCloseAndSendEcriture(CPTAECR_VALIDATE)
   #define CptaCancelEcriture(fEcr, cIDEcr)           _CptaCancelEcriture((fEcr), (cIDEcr), NULL)


 #else /* #ifndef _WIN32 */

  #include <Db.hpp>
  #include <DBTables.hpp>
  #include <DBGrids.hpp>

  #include <EIC.h>
  #include <CTable.h>
  #include <CDevise.h>
  #include <list.h>
  #include "uLetAuto.h"

  
  namespace Compta
  {
   #define COMPTE_D_ATTENTE "471ATTENTE"
   #define _loInsensitive (TLocateOptions() << loCaseInsensitive)
   #define _loNormal TLocateOptions()
   extern PACKAGE_COMPTA TDateTime      cm_DateFinExercice;       //Date de fin d'exercice pour incrémenter le solde N ou non suivant les dates d'écriture passées
   extern PACKAGE_COMPTA TDateTime      cm_DateSituation;  //Date servant pour le calcul des soldes
   extern PACKAGE_COMPTA bool cm_SoldeVisibleEgalSituation;
//   extern PACKAGE_COMPTA HWND hwndFenetreEICShell;
   extern PACKAGE_COMPTA bool cm_bEstMenufedEntreprise;


   const int IdEcritureNouvelle = 0;

   // Nature possible d'un journal
   enum JNNature {
     JNNATURE_OD          = 0,
     JNNATURE_A_NOUVEAUX,
     JNNATURE_ACHATS,  //Ex JNNATRUE_ACHATS
     JNNATURE_VENTES,
     JNNATURE_TRESORERIE,
     JNNATURE_INVENTAIRE,
     JNNATURE_BALANCE,
//     JNNATURE_ENCAISSEMENT,  // Ajouter pour les retraits et les remises en banque
//     JNNATURE_DECAISSEMENT,  //                         "
//     JNNATURE_REMISEBANQUE,  //                         "
//     JNNATURE_RETRAITBANQUE, //                         "

     JNNATURE_DEFAULT = JNNATURE_OD
   };

   // Liste des modes de paiement possible
   enum MODE_PAIEMENT { MP_AUCUN              = -1,
                        MP_ESPECES            =  0,
                        MP_CHEQUE             =  1,
                        MP_CARTEBANCAIRE      =  2,
                        MP_VIREMENT           =  3,
                        MP_PRELEVEMENT        =  5,
                        MP_EFFETCOM_RECEPTION =  6,
                        MP_EFFETCOM_ESCOMPTE  =  7,
                        MP_EFFETCOM_ENCAIS    =  8,
                        MP_TITRERESTO         = 10,
                        MP_CHEQUEVANCANCES    = 11,
                        MP_TIP                = 12,
                        MP_COMPENSATION       = 13,
                        MP_BILLET_ORDRE_REL   = 14,
                        MP_LETTRE_CHANGE_REL  = 15,
                        MP_VIREMENT_TRESO     = 16,
                        MP_TELEREGL_INTERNET  = 17,
                        MP_BILLET_ORDRE       = 18,
                        MP_LETTRE_CHANGE      = 19 };
   #define MAX_MODE_PAIEMT 18
   enum TYPE_LISTE    { TL_ACHATS=1, TL_REMISEBANQUE=2, TL_ENCAISSEMENT=4, TL_DECAISSEMENT=8, TL_TOUS=16, TL_VENTES=32 };

   #pragma pack( 2)
   typedef struct {
     enum MODE_PAIEMENT eModePaiemt;
     int                nTypeListe;
     char              *szAbreviation;
     char              *szDesignation;
   } DEF_MODE_PAIEMENT;
   #pragma pack()

   extern PACKAGE_COMPTA void               __fastcall ComptaGetListeModePaiement          ( enum TYPE_LISTE eTypeListe, TStrings *pLstAbrevation, TStrings *pLstDesignation);
   extern PACKAGE_COMPTA AnsiString         __fastcall ComptaGetDesignationPaiement        ( const AnsiString &strAbreviation);
   extern PACKAGE_COMPTA enum MODE_PAIEMENT __fastcall ComptaGetModePaiement               ( const AnsiString &strModePaiemt);
   extern PACKAGE_COMPTA enum MODE_PAIEMENT __fastcall ComptaGetModePaiementWithDesignation( const AnsiString &strDesignation);
   extern PACKAGE_COMPTA AnsiString         __fastcall ComptaGetModePaiementString         ( enum MODE_PAIEMENT eModeP);
   extern PACKAGE_COMPTA AnsiString         __fastcall ComptaGetModePaiementAbreviation    ( enum MODE_PAIEMENT eModeP);

   extern PACKAGE_COMPTA void               __fastcall ComptaSetAutoID( int nAutoID);
   extern PACKAGE_COMPTA int                __fastcall ComptaGetNewAutoID();
   extern PACKAGE_COMPTA bool               __fastcall ComptaEstUnCompteAcceptantAnalytique( const AnsiString &strCompte);
   extern PACKAGE_COMPTA bool               __fastcall ComptaEstUnCompteAnalytique(const AnsiString &strCompte);

   extern PACKAGE_COMPTA bool               __fastcall ComptaEstValide();

  enum ePeriodeCloture
  {
    epc_Inconnue = 0,
    epc_EnFonctionCabinetEntreprise,
    epc_Provisoire,
    epc_Definitive,
  };
  extern PACKAGE_COMPTA bool __fastcall ComptaPeriodeContientPeriodeCloturee( const TDateTime &dtDeb, const TDateTime &dtFin,enum ePeriodeCloture Option = epc_EnFonctionCabinetEntreprise);
  extern PACKAGE_COMPTA bool __fastcall ComptaEstDateSurPeriodeCloturee( const TDateTime &dtEcr,enum ePeriodeCloture Option = epc_EnFonctionCabinetEntreprise);

   //**********//
   // CJournal //
   //**********////////////////////////////////////////////////////////////////////
   //                                                                            //
   //    Cette classe permet de stocker les attributs d'un journal.              //
   ////////////////////////////////////////////////////////////////////////////////
   class PACKAGE_COMPTA CJournal
   {
    private:
     AnsiString    m_strCode;     //   Code   du journal (tjs en majuscules)
     AnsiString    m_strIntitule; // Intitulé "     "
     enum JNNature m_eNature;     //  Nature  "     "
    public:
     __property AnsiString    Code     = { read = m_strCode,     write = m_strCode};
     __property AnsiString    Intitule = { read = m_strIntitule, write = m_strIntitule};
     __property enum JNNature Nature   = { read = m_eNature,     write = m_eNature};
     void      __fastcall RAZ();
     CJournal& __fastcall operator = (const CJournal& jnlSrc);
     __fastcall CJournal() { RAZ(); }
     __fastcall CJournal(const AnsiString& strCode,
                          const AnsiString& strIntitule,
                          enum JNNature     eNature) : m_strCode(strCode), m_strIntitule(strIntitule), m_eNature(eNature) {}
   }; /* class CJournal */


   //***********//
   // TTableJnx //
   //***********///////////////////////////////////////////////////////////////////
   //                                                                            //
   //    Cette classe encapsule les traitements relatifs aux journaux comptables.//
   //                                                                            //
   // Clé primaire : CodeJournal                                                 //
   ////////////////////////////////////////////////////////////////////////////////
   class PACKAGE_COMPTA TTableJnx : public CTable
   {
    public:
     #define szfJN_Code                 "Code"
     #define szfJN_Intitule             "Intitule"
     #define szfJN_Nature               "Nature"    // Cf "enum JNNature"
     #define szfJN_Flags                "Flags"     // cf "enum JNFlags"
     #define szfJN_ModalitesSaisie      "ModalitesSaisie"
     #define szfJN_CompteContrepartie   "CompteContrepartie"
     #define szfJN_EncaisModSaisie      "EncaisModSaisie"
     #define szfJN_EncaisCptTreso       "EncaisCptTreso"
     #define szfJN_DeviseDefClassique   "DeviseDefClassique"
     #define szfJN_DeviseDefEncais      "DeviseDefEncais"
     #define szfJN_CodeOrigine          "CodeO"
     #define szfJN_AchVntModalSais      "AchVntModalSais"
     #define szfJN_AchVntLibelle        "AchVntLibelle"
     #define szfJN_AchVntDeviseDefaut   "AchVntDeviseDefaut"
     #define szfJN_AchVntModePaiement   "AchVntModePaiement"
     #define szfJN_AchVntCptTVA_biens   "AchVntCptTVA_biens"
     #define szfJN_AchVntCptTVA_immo    "AchVntCptTVA_immo"
     #define szfJN_AchVntCptTVA_col     "AchVntCptTVA_col"
     #define szfJN_AchVntBanquePaiement "AchVntBanquePaiement"
     #define szfJN_AchVntDateEchJour    "AchVntDateEchJour"
     #define szfJN_AchVntDateEchMode    "AchVntDateEchMode"
     #define szfJN_AchVntDateEchLe      "AchVntDateEchLe"
     #define szfJN_KmModalSais          "KmModalSais"
     #define szfJN_KmDeviseDefaut       "KmDeviseDefaut"
     #define szfJN_KmDeviseCompte       "KmDeviseCompte"
     #define szfJN_KmTauxFixe           "KmTauxFixe"
     #define szfJN_AchVntDematModalSais "AchVntDematModalSais"

     static const AnsiString strfJN_Code;
     static const AnsiString strfJN_Intitule;
     static const AnsiString strfJN_Nature;
     static const AnsiString strfJN_Flags;
     static const AnsiString strfJN_ModalitesSaisie;
     static const AnsiString strfJN_CompteContrepartie;
     static const AnsiString strfJN_EncaisModSaisie;
     static const AnsiString strfJN_EncaisCptTreso;
     static const AnsiString strfJN_DeviseDefClassique;
     static const AnsiString strfJN_DeviseDefEncais;
     static const AnsiString strfJN_CodeOrigine;
     static const AnsiString strfJN_AchVntModalSais;
     static const AnsiString strfJN_AchVntLibelle;
     static const AnsiString strfJN_AchVntDeviseDefaut;
     static const AnsiString strfJN_AchVntModePaiement;
     static const AnsiString strfJN_AchVntCptTVA_biens;
     static const AnsiString strfJN_AchVntCptTVA_immo;
     static const AnsiString strfJN_AchVntCptTVA_col;
     static const AnsiString strfJN_AchVntBanquePaiement;
     static const AnsiString strfJN_AchVntDateEchJour;
     static const AnsiString strfJN_AchVntDateEchMode;
     static const AnsiString strfJN_AchVntDateEchLe;
     static const AnsiString strfJN_KmModalSais;
     static const AnsiString strfJN_KmDeviseDefaut;
     static const AnsiString strfJN_KmDeviseCompte;
     static const AnsiString strfJN_KmTauxFixe;
     static const AnsiString strfJN_AchVntDematModalSais;

    public:
     enum JNFlags { // Valeurs possibles du champ "Flags"
       JNFLAGS_AUCUN    = 0x00000000, // Valeur par défaut du champ
       JNFLAGS_EIC      = 0x00000001, // Ce journal a été créé par EIC
       JNFLAGS_READONLY = 0x00000002  // Ce journal n'est pas modifiable et est en lecture seule (du point de vue le l'utilisateur)
     };

     enum JNModalSais { // Drapeaux possibles du champ binaire "Modalités de Saisie"
       JNModalSais_SAISIE_PIECE         = 0x00000001,
       JNModalSais_SAISIE_LIBELLE       = 0x00000002,
       JNModalSais_VALIDATION_AUTO      = 0x00000004,
       JNModalSais_RETOUR_SUR_MOIS      = 0x00000008,
       JNModalSais_RETOUR_SUR_JOUR      = 0x00000010,
       JNModalSais_RETOUR_SUR_PIECE     = 0x00000020,
       JNModalSais_CTREPARTIE_AUTO      = 0x00000040,
       JNModalSais_CTREPARTIE_SEMI_AUTO = 0x00000080,
       JNModalSais_PIECE_UNIQUE         = 0x00000100,
       JNModalSais_DEVISE_COMPTA        = 0x00000200,
       JNModalSais_DERNIERE_DEVISE      = 0x00000400,
       JNModalSais_UNGO_DEVISE          = 0x00000800,

       JNModalSais_DEFAULT = JNModalSais_SAISIE_PIECE | JNModalSais_SAISIE_LIBELLE | JNModalSais_PIECE_UNIQUE | JNModalSais_DEVISE_COMPTA
     };

     enum JNAchVntModalSaisieGeneral {
       JNAchVntModalSaisGen_PIECE_EXTERNE             = 0x00000001,
       JNAchVntModalSaisGen_PIECE_INTERNE             = 0x00000002,
       JNAchVntModalSaisGen_PIECE_INTERNE_MANUELLE    = 0x00000004,
       JNAchVntModalSaisGen_PIECE_INTERNE_AUTOMATIQUE = 0x00000008,
       JNAchVntModalSaisGen_MONTANT_TTC               = 0x00000010,

       JNAchVntModalSaisGen_RETOUR_AUTOMATIQUE        = 0x00000020,
       JNAchVntModalSaisGen_RETOUR_PIECE              = 0x00000040,
       JNAchVntModalSaisGen_RETOUR_MOIS               = 0x00000080,
       JNAchVntModalSaisGen_RETOUR_JOUR               = 0x00000100,

       JNAchVntModalSaisGen_COMPTE                    = 0x00000200,
       JNAchVntModalSaisGen_MONTANT_TENUE             = 0x00000400,
       JNAchVntModalSaisGen_LIBELLE                   = 0x00000800,
       JNAchVntModalSaisGen_QUANTITE                  = 0x00001000,

       JNAchVntModalSaisGen_ECH_DATE                  = 0x00002000,
       JNAchVntModalSaisGen_ECH_MODE_PAIEMENT         = 0x00004000,
       JNAchVntModalSaisGen_ECH_BANQUE_PAIEMENT       = 0x00008000,

       JNAchVntModalSaisGen_PASS_DEVISE               = 0x00010000,
       JNAchVntModalSaisGen_PASS_DEVISE_TENUE_COMPTA  = 0x00020000,
       JNAchVntModalSaisGen_PASS_DERNIERE_DEVISE      = 0x00040000,
       JNAchVntModalSaisGen_PASS_DEVISE_FOURNISSEUR   = 0x00080000,
       JNAchVntModalSaisGen_UNPASS_DEVISE_SPEC        = 0x00100000,
       JNAchVntModalSaisGen_UNPASS_DEVISE_FOURNISSEUR = 0x00200000,

       JNAchVntModalSaisGen_TVA_CALCUL_AUTOMATIQUE    = 0x00400000,

       JNAchVntModalSaisGen_ANALYTIK                  = 0x00800000,
       JNAchVntModalSaisGen_MONTANT_HT                = 0x01000000,
       JNAchVntModalSaisGen_RETOUR_TIERS              = 0x02000000,

       //JNAchVntModalSaisGen_PIECE_INIT_MOIS           = 0x00800000,
       //JNAchVntModalSaisGen_PIECE_INIT_EXERCICE       = 0x01000000,
       //JNAchVntModalSaisGen_PIECE_INIT_MANUELLE       = 0x02000000,
       //JNAchVntModalSaisGen_PIECE_FORMAT_N            = 0x04000000,
       //JNAchVntModalSaisGen_PIECE_FORMAT_AN           = 0x08000000,
       //JNAchVntModalSaisGen_PIECE_FORMAT_AMN          = 0x10000000,

       JNAchVntModalSaisGen_DEFAULT = JNAchVntModalSaisGen_PIECE_INTERNE          |
                                      JNAchVntModalSaisGen_PIECE_INTERNE_MANUELLE | JNAchVntModalSaisGen_RETOUR_MOIS   |
                                      JNAchVntModalSaisGen_COMPTE                 | JNAchVntModalSaisGen_MONTANT_TENUE |
                                      JNAchVntModalSaisGen_LIBELLE                | JNAchVntModalSaisGen_QUANTITE      |
                                      JNAchVntModalSaisGen_UNPASS_DEVISE_SPEC     | JNAchVntModalSaisGen_TVA_CALCUL_AUTOMATIQUE
     };

     enum JNAchVntModalSaisieLibelle {
       JNAchVntModalSaisLbl_TVA_BS_NEANT              = 0x00000001,
       JNAchVntModalSaisLbl_TVA_IMMOBIL_NEANT         = 0x00000002,
       JNAchVntModalSaisLbl_TVA_COLLECTEE_NEANT       = 0x00000004,
       JNAchVntModalSaisLbl_TTC_NEANT                 = 0x00000008,
       JNAchVntModalSaisLbl_AUTRES_NEANT              = 0x00000010,

       JNAchVntModalSaisLbl_TVA_BS_DESIGNATION        = 0x00000020,
       JNAchVntModalSaisLbl_TVA_IMMOBIL_DESIGNATION   = 0x00000040,
       JNAchVntModalSaisLbl_TVA_COLLECTEE_DESIGNATION = 0x00000080,
       JNAchVntModalSaisLbl_TTC_DESIGNATION           = 0x00000100,
       JNAchVntModalSaisLbl_AUTRES_DESIGNATION        = 0x00000200,

       JNAchVntModalSaisLbl_TVA_BS_INTITULE           = 0x00000400,
       JNAchVntModalSaisLbl_TVA_IMMOBIL_INTITULE      = 0x00000800,
       JNAchVntModalSaisLbl_TVA_COLLECTEE_INTITULE    = 0x00001000,
       JNAchVntModalSaisLbl_TTC_INTITULE              = 0x00002000,
       JNAchVntModalSaisLbl_AUTRES_INTITULE           = 0x00004000,
                                                         
       JNAchVntModalSaisLbl_TVA_BS_INTITULE_COMPTE          = 0x00008000,
       JNAchVntModalSaisLbl_TVA_IMMOBIL_INTITULE_COMPTE     = 0x00010000,
       JNAchVntModalSaisLbl_TVA_COLLECTEE_INTITULE_COMPTE   = 0x00020000,
       JNAchVntModalSaisLbl_TTC_INTITULE_COMPTE             = 0x00040000,
       JNAchVntModalSaisLbl_AUTRES_INTITULE_COMPTE          = 0x00080000,

       JNAchVntModalSaisLbl_TVA_BS_1ERE_LIGNE_DETAIL        = 0x00100000,
       JNAchVntModalSaisLbl_TVA_IMMOBIL_1ERE_LIGNE_DETAIL   = 0x00200000,
       JNAchVntModalSaisLbl_TVA_COLLECTEE_1ERE_LIGNE_DETAIL = 0x00400000,
       JNAchVntModalSaisLbl_TTC_1ERE_LIGNE_DETAIL           = 0x00800000,
       JNAchVntModalSaisLbl_AUTRES_1ERE_LIGNE_DETAIL        = 0x01000000,

       JNAchVntModalSaisLbl_DEFAULT = JNAchVntModalSaisLbl_TVA_BS_NEANT        | JNAchVntModalSaisLbl_TVA_IMMOBIL_NEANT |
                                      JNAchVntModalSaisLbl_TVA_COLLECTEE_NEANT | JNAchVntModalSaisLbl_TTC_NEANT         |
                                      JNAchVntModalSaisLbl_AUTRES_NEANT
     };

     enum JNKmModalSaisie {
       JNKmModalSais_PIECE_INTERNE_MANUELLE = 0x00000001,
       JNKmModalSais_PIECE_INTERNE_AUTO     = 0x00000002,
       JNKmModalSais_LIBELLE_DEF_COMPTE     = 0x00000004,
       JNKmModalSais_LIBELLE_DEF_PRECEDENT  = 0x00000008,
       JNKmModalSais_LIBELLE_DEF_NEANT      = 0x00000010,
       JNKmModalSais_DEVISE_DEF_TENUE       = 0x00000020,
       JNKmModalSais_DEVISE_DEF_DERNIERE    = 0x00000040,
       JNKmModalSais_DEVISE_DEF_SPEC        = 0x00000080,
       JNKmModalSais_DEVISE_DEF_NEANT       = 0x00000100,
       JNKmModalSais_TAUX_SAISI             = 0x00000200,
       JNKmModalSais_TAUX_FIXE              = 0x00000400,
       JNKmModalSais_LIBELLE_A_ECRASER      = 0x00000800, // sinon à compléter

       JNKmModalSais_DEFAULT                = JNKmModalSais_PIECE_INTERNE_MANUELLE | JNKmModalSais_LIBELLE_DEF_NEANT |
                                              JNKmModalSais_DEVISE_DEF_TENUE       | JNKmModalSais_TAUX_SAISI
     };

     enum JNEncModalSais { // Drapeaux possibles du champ binaire "Modalités de Saisie des encaissements"
       JNEncModalSais_PIECE                  = 0x00000001,
       JNEncModalSais_FACTURE                = 0x00000002,
       JNEncModalSais_RETOUR_AUTOMATIQUE     = 0x00000004,
       JNEncModalSais_RETOUR_PIECE           = 0x00000008,
       JNEncModalSais_RETOUR_MOIS            = 0x00000010,
       JNEncModalSais_RETOUR_JOUR            = 0x00000020,
       JNEncModalSais_NATURE_PIECE           = 0x00000040,
       JNEncModalSais_AFFICHAGE_CLIENTS_AUTO = 0x00000080,
       JNEncModalSais_DEVISE_COMPTA          = 0x00000100,
       JNEncModalSais_DERNIERE_DEVISE        = 0x00000200,
       JNEncModalSais_UNGO_DEVISE            = 0x00000400,
       // Modalités de saisie des décaissements
       JNDecModalSais_PIECE                  = 0x00010000,
       JNDecModalSais_FACTURE                = 0x00020000,
       JNDecModalSais_RETOUR_AUTOMATIQUE     = 0x00040000,
       JNDecModalSais_RETOUR_PIECE           = 0x00080000,
       JNDecModalSais_RETOUR_MOIS            = 0x00100000,
       JNDecModalSais_RETOUR_JOUR            = 0x00200000,
       JNDecModalSais_NATURE_PIECE           = 0x00400000,
       JNDecModalSais_AFFICHAGE_FOURNIS_AUTO = 0x00800000,
       JNDecModalSais_DEVISE_COMPTA          = 0x01000000,
       JNDecModalSais_DERNIERE_DEVISE        = 0x02000000,
       JNDecModalSais_UNGO_DEVISE            = 0x04000000,

       JNEncModalSais_DEFAULT = JNEncModalSais_PIECE         | JNEncModalSais_FACTURE     |
                                JNEncModalSais_NATURE_PIECE  | JNEncModalSais_RETOUR_MOIS |
                                JNEncModalSais_DEVISE_COMPTA |
                                JNDecModalSais_PIECE         | JNDecModalSais_FACTURE     |
                                JNDecModalSais_NATURE_PIECE  | JNDecModalSais_RETOUR_MOIS |
                                JNDecModalSais_DEVISE_COMPTA
     };

    // Propriétés redéfinies
    __published:
     __property EICCodeTable = { stored = false}; // Initialisé via constructeur

    // Nouvelles propriétés
    private:
     typedef CTable inherited;
     bool __fastcall GetAFlagIsOn(int fFlags);
     bool __fastcall GetReadOnly();
     AnsiString __fastcall GetJournalAN();

    public:
     static bool VoirJournauxInventaires;
     static bool CocheOCRpourJournauxAchat;
     static bool CocheOCRpourJournauxVente;

     __property bool EstEIC      = { read = GetAFlagIsOn, index = JNFLAGS_EIC};
     __property bool EstReadOnly = {read = GetReadOnly};
     __property AnsiString AN = {read = GetJournalAN};

    // Les opérations suivantes modifient l'enregistrement courant de la table
     __fastcall TTableJnx(TComponent* pOwner);
     virtual __fastcall ~TTableJnx() {};
     void          __fastcall Get(const AnsiString& strCodeJnl, CJournal& jnl);
     bool          __fastcall Exist(const AnsiString& strCodeJnl);
     enum JNNature __fastcall Nature(const AnsiString& strCodeJnl);
     bool          __fastcall Creer(const CJournal& jnl);
     bool          __fastcall CreerDlg(EICTag            tag,
                                        const AnsiString& strNewCodeJnl,
                                        bool&             bExisteDeja,
                                        void*             hInstance = HInstance);
     AnsiString __fastcall Selectionner(bool VoirEIC = true,bool VoirReadOnly = false);
     void          __fastcall Modifier(const CJournal& jnl);
     void          __fastcall GetNaturesJnl( TStrings *pNatures);
     AnsiString    __fastcall GetTextNature( JNNature eNature);

    // Les opérations suivantes ne modifient pas l'enregistrement courant de la table
     bool __fastcall ModifierCourantDlg(EICTag tag); // TRUE s'il y a eu modification
   }; /* class TTableJnx */


   //*********//
   // CCompte //
   //*********/////////////////////////////////////////////////////////////////////
   //                                                                            //
   //    Cette classe permet de stocker les attributs d'un compte du PC.         //
   ////////////////////////////////////////////////////////////////////////////////
   class PACKAGE_COMPTA CCompte
   {
    private:
     AnsiString m_strCompte,m_CompteO;       // N° du compte
     AnsiString m_strIntitule;     // Intitulé usuel du compte
     AnsiString m_strIntituleLong; //     "    long  "    "
     TCodeDev   m_eCodeDevise;     // Code de la devise par défaut du compte
     Currency   m_curDebit;        // Débit  Exercice N
     Currency   m_curCredit;       // Crédit    "     "
     bool       m_bMouvementeNm1;  // TRUE si le compte a été mouvementé sur N-1
     Currency   m_curSoldeNm1;     // Solde N-1 (à zéro en lecture si m_bMouvementeNm1 est false, ignoré en écriture si m_bMouvementeNm1 est false)
     bool       m_bMouvementeNm2;  // TRUE si le compte a été mouvementé sur N-2
     Currency   m_curSoldeNm2;     // Solde N-2 (à zéro en lecture si m_bMouvementeNm2 est false, ignoré en écriture si m_bMouvementeNm2 est false)
     bool       m_bMouvementeNm3;  // TRUE si le compte a été mouvementé sur N-3
     Currency   m_curSoldeNm3;     // Solde N-3 (à zéro en lecture si m_bMouvementeNm3 est false, ignoré en écriture si m_bMouvementeNm3 est false)
     bool       m_bMouvementeNm4;  // TRUE si le compte a été mouvementé sur N-4
     Currency   m_curSoldeNm4;     // Solde N-4 (à zéro en lecture si m_bMouvementeNm4 est false, ignoré en écriture si m_bMouvementeNm4 est false)
     bool       m_bRANDetaille;    // TRUE si le Report A Nouveau du compte doit être détaillé
     bool       m_bSupprime;       //  "   "  "  compte est supprimé
    private:
     // Les Get
     inline const AnsiString& __fastcall GetCompte()       const { return(m_strCompte);}
     inline const AnsiString& __fastcall GetIntitule()     const { return(m_strIntitule);}
     inline const AnsiString& __fastcall GetIntituleLong() const { return(m_strIntituleLong);}
     inline const Currency&   __fastcall GetDebit()        const { return(m_curDebit);}
     inline const Currency&   __fastcall GetCredit()       const { return(m_curCredit);}
     inline const Currency    __fastcall GetSolde()        const { return(m_curDebit - m_curCredit);}

     // Les Set
     inline void __fastcall SetCompte(const AnsiString& strCompte)             { m_strCompte       = strCompte;}
     inline void __fastcall SetIntitule(const AnsiString& strIntitule)         { m_strIntitule     = strIntitule;}
     inline void __fastcall SetIntituleLong(const AnsiString& strIntituleLong) { m_strIntituleLong = strIntituleLong;}

    public:
     __property const AnsiString Compte           = { read = GetCompte,        write = SetCompte};
     __property const AnsiString CompteOrigine    = { read = m_CompteO,        write = m_CompteO};
     __property const AnsiString Intitule         = { read = GetIntitule,      write = SetIntitule};
     __property const AnsiString IntituleLong     = { read = GetIntituleLong,  write = SetIntituleLong};
     __property TCodeDev         CodeDevise       = { read = m_eCodeDevise,    write = m_eCodeDevise};
     __property const Currency   Debit            = { read = GetDebit,         write = m_curDebit};
     __property const Currency   Credit           = { read = GetCredit,        write = m_curCredit};
     __property Currency         Solde            = { read = GetSolde};
     __property bool             EstMouvementeNm1 = { read = m_bMouvementeNm1, write = m_bMouvementeNm1};
     __property Currency         SoldeNm1         = { read = m_curSoldeNm1,    write = m_curSoldeNm1};
     __property bool             EstMouvementeNm2 = { read = m_bMouvementeNm2, write = m_bMouvementeNm2};
     __property Currency         SoldeNm2         = { read = m_curSoldeNm2,    write = m_curSoldeNm2};
     __property bool             EstMouvementeNm3 = { read = m_bMouvementeNm3, write = m_bMouvementeNm3};
     __property Currency         SoldeNm3         = { read = m_curSoldeNm3,    write = m_curSoldeNm3};
     __property bool             EstMouvementeNm4 = { read = m_bMouvementeNm4, write = m_bMouvementeNm4};
     __property Currency         SoldeNm4         = { read = m_curSoldeNm4,    write = m_curSoldeNm4};
     __property bool             RANDetaille      = { read = m_bRANDetaille,   write = m_bRANDetaille};
     __property bool             Supprime         = { read = m_bSupprime,      write = m_bSupprime};

    public:
     void     __fastcall RAZ();
     CCompte& __fastcall operator = (const CCompte& cptSrc);
    public:
     __fastcall CCompte();
     __fastcall CCompte(const char* pcszCompte, const char* pcszIntitule);
     static bool __fastcall EstUnCompteValide(const char* pcszCompte);
   }; /* class CCompte */

   class cRacineTypeEnr
   {
   public:
    AnsiString strRacine;
    int TypeEnr;
    __fastcall cRacineTypeEnr()
    {
      TypeEnr = 0;
    }
    __fastcall cRacineTypeEnr( const cRacineTypeEnr &RacineTypeEnr)
    {
      strRacine = RacineTypeEnr.strRacine;
      TypeEnr = RacineTypeEnr.TypeEnr;
    }
    bool __fastcall operator <( const cRacineTypeEnr &RacineTypeEnr) const
    {
      if (strRacine == RacineTypeEnr.strRacine)
        return TypeEnr < RacineTypeEnr.TypeEnr;
      else
        return strRacine < RacineTypeEnr.strRacine;
    }
    bool __fastcall operator ==( const cRacineTypeEnr &RacineTypeEnr) const
    {
      return (strRacine == RacineTypeEnr.strRacine) && (TypeEnr == RacineTypeEnr.TypeEnr);
    }
   };
   typedef std::map<cRacineTypeEnr,enum CODE_CYCLE> MapRacineCycle;

   //**********//
   // TTablePC //
   //**********////////////////////////////////////////////////////////////////////
   //                                                                            //
   //    Cette classe permet de gérer un plan comptable (qui contient des        //
   // comptes et un programme de travail).                                       //
   //                                                                            //
   // Clé primaire : Compte + Cycle + TypeEnr                                    //
   ////////////////////////////////////////////////////////////////////////////////
   class TTablePT; // La classe TTablePC en a besoin
   class PACKAGE_COMPTA TTablePC : public CTable
   {
    public:
     #define szfPC_Compte          "Compte"
     #define szfPC_Cycle           "Cycle"
     #define szfPC_TypeEnr         "TypeEnr"      // cf <<enum PC_EnregType>>
     #define szfPC_CodeDevise      "Devise"       // Code de la devise par défaut du compte (CODE_DEVISE_DEFAUT par défaut)
     #define szfPC_Intitule        "Intitule"
     #define szfPC_IntituleLong    "IntituleLong"
     #define szfPC_Lettrable       "Lettrable"
     #define szfPC_Supprime        "Supprime"
     #define szfPC_Visa            "Visa"         // cf <<enum PC_Visa>>
     #define szfPC_Flags           "Flags"        // cf <<enum PC_Flag>>
     #define szfPC_Drapeaux        "Drapeaux"     // Jolis drapeaux bien gérés ( flag mieux géré que Flags)
     #define szfPC_Debit           "Debit"        // Masse des débits de cloture ou de situation suivant la situation (dans la devise du dossier)
     #define szfPC_Credit          "Credit"       //   "    "  crédits    "   "    "    "     "
     #define szfPC_DebitSituation  "DebitSit"     // Masse des débits N jusqu'à la date de situation (dans la devise du dossier)
     #define szfPC_CreditSituation "CreditSit"    //   "    "  crédits N   "   "    "    "     "
     #define szfPC_DebitTotal      "DebitTotal"   // Masse des débits (dans la devise du dossier)
     #define szfPC_CreditTotal     "CreditTotal"  //   "    "  crédits   "   "    "    "     "
     #define szfPC_SoldeNm1        "SoldeNm1"     //   "    "   "   "    "    du dossier
     #define szfPC_SoldeNm2        "SoldeNm2"     //   "    "   "   "    "    du dossier
     #define szfPC_SoldeNm3        "SoldeNm3"     //   "    "   "   "    "    du dossier
     #define szfPC_SoldeNm4        "SoldeNm4"     //   "    "   "   "    "    du dossier
     #define szfPC_CompteOrigine   "CompteO"      // Compte équivalent dans la compta d'origine (si ce compte a été importé)
     #define szfPC_IDImage         "IDImage"
     #define szfPC_SoldeNm1Origine "SoldeNm1O"    // Solde N-1 dans la devise d'origine N-1 (Champ supprimé le 31/10/03)
     #define szfPC_SoldeNm2Origine "SoldeNm2O"    //   "   N-2  "   "    "    d'origine N-2 (Champ supprimé le 31/10/03)
     static const AnsiString strfPC_Compte;
     static const AnsiString strfPC_Cycle;
     static const AnsiString strfPC_TypeEnr;
     static const AnsiString strfPC_CodeDevise;
     static const AnsiString strfPC_Intitule;
     static const AnsiString strfPC_IntituleLong;
     static const AnsiString strfPC_Lettrable;
     static const AnsiString strfPC_Supprime;
     static const AnsiString strfPC_Visa;
     static const AnsiString strfPC_Flags;
     static const AnsiString strfPC_Drapeaux;
     static const AnsiString strfPC_Debit;
     static const AnsiString strfPC_Credit;
     static const AnsiString strfPC_DebitSituation;
     static const AnsiString strfPC_CreditSituation;
     static const AnsiString strfPC_DebitTotal;
     static const AnsiString strfPC_CreditTotal;
     static const AnsiString strfPC_SoldeNm1;
     static const AnsiString strfPC_SoldeNm2;
     static const AnsiString strfPC_SoldeNm3;
     static const AnsiString strfPC_SoldeNm4;
     static const AnsiString strfPC_CompteOrigine;
     static const AnsiString strfPC_IDImage;

    public:
     // Valeurs possibles du champ "TypeEnregistrement"
     enum PCTypeEnr {
      PCTYPEENR_COMPTE        = 0,               // L'enregistrement représente un compte
      PCTYPEENR_PROGRAMME_DE_TRAVAIL,            // L'enregistrement représente un programme de travail
      PCTYPEENR_COMPTE_COLLECTIF,                // L'enregistrement représente un compte collectif

      #define NB_PCTYPEENR 3                     //Nombre de valeurs possibles pour le champ 'TypeEnr'
     };
     #define EST_UN_COMPTE(T) ((T) == TTablePC::PCTYPEENR_COMPTE)
     #define EST_UN_COMPTE_COLLECTIF(T) ((T) == TTablePC::PCTYPEENR_COMPTE_COLLECTIF)

     // Définition des valeurs binaires possibles du champ "Flags"
     enum PCFlags {
       PCFLAGS_AUCUN                 = 0x00000000, // Valeur par défaut du champ
       PCFLAGS_COMPTE_CYCLE_FINAL    = 0x00000001, // Ce compte doit figurer dans le cycle final
       PCFLAGS_IMAGE_MODIFIEE        = 0x00000002, // L'image sur le compte a été modifiée
     };

     enum PCDrapeaux {
       PCDRAPEAUX_AUCUN             = 0x00000000,// Valeur par défaut du champ
       PCDRAPEAUX_COMPTE_AUXILIAIRE = 0x00000001,// L'enregistrement représente un compte collectif

       NB_PCDRAPEAUX = 2                         //Nombre le valeurs possibles pour le champ 'Drapeaux'
     };
     #define EST_AUX(X) ((X) & TTablePC::PCDRAPEAUX_COMPTE_AUXILIAIRE)

     #define EST_UN_COMPTE_NORMAL(T,D) (EST_UN_COMPTE(T) && !EST_AUX(D))
     #define EST_UN_COMPTE_AUXILIAIRE(T,D) (EST_UN_COMPTE(T) && EST_AUX(D))

     // Valeurs possibles du champ "Visa"
     enum PCVisa {
       PCVISA_AUCUN                   = 0x00000000,
       PCVISA_ORDINAIRE_PAR_ORDINAIRE = 0x00000001, // Visa ordinaire posé dans un cycle ordinaire
       PCVISA_ORDINAIRE_PAR_FINAL     = 0x00000002, //  "       "      "    "   le cycle final
       PCVISA_FINAL_PAR_FINAL         = 0x00000004, //  Visa final (posé obligatoirement dans le cycle final)

       PCVISA_PROGRAMME_DE_TRAVAIL    = 0x00000007  // Tous les visas d'un compte
     };
     #define EST_VISE_ORDINAIRE(X) ((X) & TTablePC::PCVISA_ORDINAIRE_PAR_ORDINAIRE)

    private:
     // Attributs de classe
     static bool         cm_bIsExEuro;           // TRUE si la devise de l'exercice  N   est  l'Euro
    public:
     static AnsiString   cm_strCptPerteArrondis;  // Compte des pertes  sur arrondis Devises Zone Européenne/Euro
     static AnsiString   cm_strCptProfiArrondis;  //   "     "  profits  "     "                 "

     static void __fastcall InitClassMembers( bool             bIsExEuro,
                                              const TDateTime &DateFinExercice,
                                              const TDateTime &DateSituation,
                                              bool Situation);

    // Propriétés redéfinies
    __published:
     __property EICCodeTable = { stored = false}; // Initialisé via constructeur

    // Nouvelles propriétés
    private:
     void     __fastcall SetDrapeaux( bool bValue, PCDrapeaux eIndex);

     Currency __fastcall GetSolde(        int eIDExercice); // Solde N, N-1 ou N-2 du cpt courant
     bool     __fastcall GetEstMouvemente(int eIDExercice); // Cpt courant mouvementé sur N ou N-1 ?
     bool     __fastcall GetEstVise(int bViseFinal);        // Le cpt/PT courant est-il visé (ordinaire ou final) ?
     Currency __fastcall GetResultat();
     Currency __fastcall GetResultatSituation();
      bool __fastcall GetEstUnCompte();
      bool __fastcall GetEstUnCompteNormal();
      bool __fastcall GetEstUnCompteAuxiliaire();
      bool __fastcall GetEstUnProgrammeDeTravail();
     bool     __fastcall GetEstUnCompteCollectif();
     bool     __fastcall GetDrapeaux( int nIndex);

    public:
     // Classe
     __property AnsiString CptPerteArrondis = { read = cm_strCptPerteArrondis};
     __property AnsiString CptProfiArrondis = { read = cm_strCptProfiArrondis};
     __property bool       IsExEuro        = { read = cm_bIsExEuro};

    public:
     __property Currency Solde                 = { read = GetSolde,         index = IDEXERCICE_N};
     __property Currency SoldeNm1              = { read = GetSolde,         index = IDEXERCICE_Nm1};
     __property Currency SoldeNm2              = { read = GetSolde,         index = IDEXERCICE_Nm2};
     __property bool     EstMouvemente         = { read = GetEstMouvemente, index = IDEXERCICE_N};
     __property bool     EstMouvementeNp1      = { read = GetEstMouvemente, index = IDEXERCICE_Np1};
     __property bool     EstMouvementeNm1      = { read = GetEstMouvemente, index = IDEXERCICE_Nm1};
     __property bool     EstMouvementeNm2      = { read = GetEstMouvemente, index = IDEXERCICE_Nm2};
     __property bool     EstMouvementeNm3      = { read = GetEstMouvemente, index = IDEXERCICE_Nm3};
     __property bool     EstMouvementeNm4      = { read = GetEstMouvemente, index = IDEXERCICE_Nm4};
     __property bool     EstViseOrdinaire      = { read = GetEstVise,       index = false}; // Valable pour un PT
     __property bool     EstViseFinal          = { read = GetEstVise,       index = true};  // Valable pour un PT
     __property Currency Resultat              = { read = GetResultat};
     __property Currency ResultatSituation     = { read = GetResultatSituation};
     __property bool     EstDejaMouvemente     = { read = GetEstMouvemente, index = IDEXERCICE_COURANT};
     __property bool     EstUnCompte  = {read = GetEstUnCompte};     //Normal ou auxiliaire
     __property bool     EstUnCompteNormal  = {read = GetEstUnCompteNormal};
     __property bool     EstUnCompteCollectif  = {read = GetEstUnCompteCollectif};
     __property bool     EstUnCompteAuxiliaire  = {read = GetEstUnCompteAuxiliaire};
     __property bool     EstUnProgrammeDeTravail  = {read = GetEstUnProgrammeDeTravail};
     __property bool     EstAuxiliaire = { read = GetDrapeaux, index = PCDRAPEAUX_COMPTE_AUXILIAIRE };

     static bool __fastcall EstLeCollectifDe(const AnsiString &CompteAux,const AnsiString &CompteCollectif);
            void __fastcall SupprimerCompteCollectif( const AnsiString &strCompteCollectif);
    private:
            void            __fastcall OuvrirTableCycles(CTable*& ptblCycles);
     static void            __fastcall FermerTableCycles(CTable*& ptblCycles);

     static enum CODE_CYCLE __fastcall GetPropsUnCompte(MapRacineCycle *mapRacineCycle,
                                                         const AnsiString& strCompte,
                                                         bool&             bIntoCycleFinal);
     /*static enum CODE_CYCLE __fastcall GetPropsUnCompte(CTable*           ptblCycles,
                                                         const AnsiString& strCompte,
                                                         bool&             bIntoCycleFinal);*/
            enum CODE_CYCLE __fastcall GetPropsCompte(const AnsiString& strCompte,
                                                       bool&             bIntoCycleFinal);
     static void __fastcall CreerMapRacineCycle(CTable *ptblCycles,MapRacineCycle *mapRacineCycle);


    //****************************//
    // Opérations sur les comptes //
    //****************************//
    // Les opérations suivantes modifient l'enregistrement courant de la table
    public:
     bool       __fastcall AllerSurLeCompte(const AnsiString& strCompte);        // TRUE si trouvé
     bool __fastcall AllerSurLeCompteCollectif(const AnsiString &Collectif);
     bool       __fastcall AllerSurLeCompteCollectifDe(const AnsiString &Compte);// TRUE si trouvé
     bool       __fastcall GetCompte(const AnsiString& strCompte, CCompte& cpt); // TRUE si trouvé
     bool       __fastcall CreerCompte(const CCompte& cpt);// TRUE si bien inséré (i.e. le cpt n'existe pas déjà)
     bool       __fastcall CreerCompteDlg(EICTag   tag,
                                           bool     bNoCptASaisir, // TRUE si l'utilisateur doit saisir un nouveau n° de cpt
                                           CCompte& cptCree,
                                           void*    hInstance = HInstance); // TRUE si bien créé (i.e. non abandonné par l'utilisateur)
     bool       __fastcall CreerCompteCollectif( const CCompte& cpt, bool bCreate);
     bool __fastcall SupprimerCompte(bool PoserUneQuestion,bool MessageSiNonSupprimable = true);
  bool __fastcall CalculerDebitCreditCollectif(const AnsiString &CompteCollectif);
  void __fastcall CalculerSoldesCollectifs();
  void __fastcall RecalculerSoldesArchive(const AnsiString &NomArchive,int IDExercice);
     void       __fastcall CreerCompteStandard(EICTag             tag,
                                               const AnsiString &Compte,
                                               const AnsiString &Libelle,
                                                void*              hInstance = HInstance); // Le compte devient le compte courant
     void       __fastcall CreerComptesArrondis();
     AnsiString __fastcall CreerCompteRepriseDeDotation(const AnsiString& strCptDotation, bool bCreerCptReprise = true);
     void       __fastcall ModifierCompte(const CCompte& cpt);
     void       __fastcall RAZSoldes(EICTag tag, int eIDExercice, CBarre* pbarre, int hInstance = (int)HInstance);
//     void       __fastcall ImporterCompte(const CCompte& cpt, int eIDExercice);
     void       __fastcall RecalculerCycles(CBarre *Barre = 0,bool ModifierANDetailles = false);
     void __fastcall RecalculerCycle(const AnsiString &Compte,int &Cycle,bool &CycleFinal);
     bool __fastcall ChangerSoldes(bool Situation);
     bool __fastcall EquilibrerNm1Nm2Tenue();
     void __fastcall ConvertirSoldesNm1Nm2TenueEuro( CBarre *pBarre = NULL);

    // Les opérations suivantes ne modifient pas l'enregistrement courant de la table
    public:
     void __fastcall GetCompteCourant(CCompte& cptCourant); // Caractéristiques sur N uniquement
     void __fastcall ViserCompteCourant(bool bViser, bool bVisaFinal);
     bool __fastcall ModifierCompteCourantDlg(EICTag tag, void* hInstance = HInstance); // TRUE s'il y a eu modification


    //************************//
    // Opérations de filtrage //
    //************************//
    public:
     void __fastcall FiltrerCycle(enum CODE_CYCLE eCycle,bool bVoirPT,bool bVoirComptesVises,bool FilteredATrue = false);
     void __fastcall FiltrerProgrammeDeTravail();

    public:
     bool __fastcall EstUnCompteExistant(const AnsiString& strCompte);
     void __fastcall ChangeSolde(const AnsiString& strCompte,const Currency& curMontant,bool bCredit,const TDateTime &DateOperation,bool Collectif = false);
     // Les opérations suivantes modifient l'enregistrement courant de la table
     bool __fastcall AllerSurLeProgrammeDeTravail(const AnsiString& strRacine);// TRUE si trouvé
     bool __fastcall CreerProgrammeDeTravail(const AnsiString& strRacine,const AnsiString& strDesignation,TTablePT * Table_PT);// TRUE si bien inséré
     bool __fastcall SupprimerAncienPTCommun(TTablePT * Table_PT,CBarre *Barre = 0);
     bool __fastcall RestaurerAncienVisaPTCommun(TTablePT * Table_PT,CBarre *Barre = 0);
     void __fastcall SupprimerProgrammeDeTravail(TTablePT * Table_PT);

     // Les opérations suivantes ne modifient pas l'enregistrement courant de la table
     void __fastcall ViserProgrammeDeTravail(bool bViser,TTablePT * Table_PT = NULL);
    private:
     typedef CTable inherited;
    public:
     __fastcall TTablePC(TComponent* pOwner);
   }; /* class TTablePC */


   //*****************//
   // TChangeResultat //
   //***************************************************************************
   //
   //   Structure avec tous les renseignements pour modifier le résultat
   //   comptable à la date de situation
   //
   //***************************************************************************
  typedef union
    {
      double Double64Bits;
      struct
        {
          int PartieHaute;
          int PartieBasse;
        } Ints32Bits;
    } TChangeResultat;


   //*******************//
   // TLigneEcartChange //
   //***************************************************************************
   //
   //   Structure définissant une ligne d'écriture de l'écart de change.
   //   Utilisée essentiellement dans l'écran Encaissments/Décaissements
   // et dans la classe TEcartChgEcriture.
   //
   //***************************************************************************
#pragma pack(2)
   typedef struct {
     CCompte    Compte;        // N° du compte à créditer ou à débiter
     AnsiString strLibelle;    // Libellé de la ligne d'écriture
     bool       bIsCrediteur;  // Montant créditeur ou débiteur de la ligne
     Currency   curMontant;
     int        nReviseur;
     int        nReference;
   } TLigneEcartChange;
#pragma pack()

   //*******************//
   // TEcartChgEcriture //
   //***************************************************************************
   //
   //   Classe servant à la gestion d'une liste d'écart de change à générer
   // dans une écriture. Chaque élément correspond a une ligne de l'écriture.
   //
   //***************************************************************************
   class PACKAGE_COMPTA TEcartChgEcriture
   {
     private:
       TList *m_pLstEcr;

       int __fastcall GetCount() const;
       TLigneEcartChange *__fastcall GetItems( int nIndex) const;

     public:
       __fastcall  TEcartChgEcriture();
       virtual __fastcall ~TEcartChgEcriture();

       void __fastcall Add( const CCompte &vCompte, const AnsiString &vstrLibelle, bool vbIsCrediteur, const Currency &vcurMontant);
       void __fastcall Add( const TLigneEcartChange &sChange);
       void __fastcall Delete( int nIndex);
       void __fastcall Clear();

       __property int Count = { read=GetCount };
       __property TLigneEcartChange *Items[int nIndex] = { read=GetItems };
   }; /* class TEcartChgEcriture */

#define CUR_MAX (( __int64)0x7FFFFFFFFFFFFFFF)
#pragma pack( 2)
class TLetAuto {
  public:
    Currency  curValue;
    TDateTime dtImput;
    int       nAutoID;
    TCodeDev  Devise;
    double    dTauxChg;
    bool      bUsed;
    bool __fastcall Egal         ( const TLetAuto &pVal2) { return ( curValue==pVal2.curValue); };
    bool __fastcall InferieurEgal( const TLetAuto &pVal2) { return ( curValue<=pVal2.curValue); };
    bool __fastcall IsLast(){ return curValue.Val==CUR_MAX; }
    bool __fastcall IsBusy(){ return bUsed; }
};
#pragma pack()

enum RET_SEARCH { RS_OK, RS_NOK, RS_ABORT };

   //**********//
   // TTableHI //
   //**********////////////////////////////////////////////////////////////////////
   //                                                                            //
   //    Cette classe permet de gérer un historique comptable.                   //
   //                                                                            //
   // Clé primaire : DateImputation + AutoID                                     //
   ////////////////////////////////////////////////////////////////////////////////
   // Composition des code d'origine d'écriture (11=1èreLettre,22=2èmeLettre,33=3èmeLettre,PP=LettrePersonnelle) :
   //                 RAOIDECRITURE     : 0x221100PP
   //                 PRODUCTIDECRITURE : 0xPP332211
   #define STR_MESSAGE_RESULTAT_DATE "COMPTA_CALCULER_RESULTAT_DATE" //Message pour incrémenter le résultat comptable ; WParam = Montant, LParam = Date d'imputation
   #define STR_MESSAGE_RESULTAT_MONTANT "COMPTA_CALCULER_RESULTAT_MONTANT" //Message pour incrémenter le résultat comptable ; WParam = Montant, LParam = Date d'imputation
   #define MAKERAOIDECRITURE(cModuleCodeFirst, cModuleCodeSecond, cModulePersonal)                           (unsigned int)((((cModuleCodeFirst)&0xFF)<<16)|(((cModuleCodeSecond)&0xFF)<<24)|((cModulePersonal)&0xFF))
   #define MAKEPRODUCTIDECRITURE(cProductCodeFirst, cProductCodeSecond, cProductCodeThird, cProductPersonal) (unsigned int)(((cProductCodeFirst)&0xFF)|(((cProductCodeSecond)&0xFF)<<8)|(((cProductCodeThird)&0xFF)<<16)|(((cProductPersonal)&0xFF)<<24))
   #define IS_ARAOIDECRITURE(eRAOIDEcriture)                                                                 (!((eRAOIDEcriture)&0x0000FF00))
   #define IS_THERAOIDECRITURE(cModuleCodeFirst, cModuleCodeSecond, eIDEcriture)                             (((eIDEcriture)&0xFFFFFF00)==MAKERAOIDECRITURE((cModuleCodeFirst), (cModuleCodeSecond), 0x00))
   #define IS_APRODUCTIDECRITURE(eProductIDEcriture)                                                         ((eProductIDEcriture)&0xFF000000)
   #define IS_THEPRODUCTIDECRITURE(cProductCodeFirst, cProductCodeSecond, cProductCodeThird, eIDEcriture)    (((eIDEcriture)&0x00FFFFFF)==MAKEPRODUCTIDECRITURE((cProductCodeFirst), (cProductCodeSecond), (cProductCodeThird), 0x00))
   #define RAOIDECRITURE_PERSONALCODE(eRAOIDEcriture)                                                        (unsigned char)((eRAOIDEcriture)&0x000000FF)
   #define PRODUCTIDECRITURE_PERSONALCODE(eProductIDEcriture)                                                (unsigned char)((eProductIDEcriture)>>24)
   #define RAOIDECRITURE_FONCTION_BASE                                                                        MAKEPRODUCTIDECRITURE(0xFF, 0xFF, 0xFF, 0xFF)
   #define REVAOIDECRITURE(cRevAOPersonal)                                                                   MAKEPRODUCTIDECRITURE(  'R', 'E', 'V', (cRevAOPersonal))
   #define IS_REVAOIDECRITURE(eIDEcriture)                                                                   IS_THEPRODUCTIDECRITURE('R', 'E', 'V', (eIDEcriture))
   #define TENCOIDECRITURE(cTenCoPersonal)                                                                   MAKEPRODUCTIDECRITURE(  'T', 'E', 'N', (cTenCoPersonal))
   #define IS_TENCOIDECRITURE(eIDEcriture)                                                                   IS_THEPRODUCTIDECRITURE('T', 'E', 'N', (eIDEcriture))
   #define INITSOLDEIDECRITURE                                                                               MAKEPRODUCTIDECRITURE( 'S', 'F', 'I', 'S')
   #define SAISIEEXTIDECRITURE                                                                               MAKEPRODUCTIDECRITURE( 'S', 'F', 'E', 'C')


// ATTENTION !!!!
// Ne pas modifier les valeurs des écrans
// car ils sont utilisés dans le HI pour reconnaitre
// de quel écran provient l'écriture
//
// Si ajout de nouvelle valeur vérifier les fonctions suivantes
// 'TfrmDecais::EcritureEstUneFacture' et 'BaseModifierEcritures'
enum TYPE_ECRAN { TE_ENCAISSEMENTS='0', TE_DECAISSEMENTS='1', TE_ANOUVEAUX='2', TE_REMISEBANQUE='3',
                  TE_FORMULAIRE='4', TE_KILOMETRE='5', TE_ACHATS='A', TE_VENTES='G',
                  TE_FACT_AVOIR_FOURN='B', TE_FACT_AVOIR_CLIENTS='H',TE_FORMULAIRE_DEMAT = '6',
                  TE_CLASSIQUE_DEMAT = '7', TE_ENCAISSEMENTS_DEMAT = '8',TE_DECAISSEMENTS_DEMAT = '9' };
// 'A'->'F' : Réservé aux achats
// 'G'->'L' : Réservé aux ventes


   class CEcriture;
   class CPropsEcriture;
   class TTableHITmp;
   class PACKAGE_COMPTA TTableHI : public CTable
   {
    friend class TTableHITmp;
    friend class CEcriture;
    public:
     #define szfHI_DateImputation   "DateImputation"
     #define szfHI_AutoID           "AutoID"           // Auto-incrémenté
     #define szfHI_Compte           "Compte"
     #define szfHI_CodeJournal      "CodeJournal"
     #define szfHI_RANDateOrigine   "RANDateO"         //   Code journal    d'origine pour un RAN détaillé (cf. HIFLAGS_A_NOUVEAU_DETAILLE)
     #define szfHI_RANJnlOrigine    "RANJnlO"          // Date d'imputation     "      "   "   "      "     "               "
     #define szfHI_Piece            "Piece"
     #define szfHI_PieceExterne     "PieceExt"
     #define szfHI_NaturePiece      "NaturePiece"
     #define szfHI_PieceLiee        "PieceLiee"
     #define szfHI_Lettrage         "Lettrage"         // "" par défaut
     #define szfHI_FlagLettrage     "FlagLettrage"     // "Non lettré" par défaut
     #define szfHI_IDEcriture       "IDEcriture"
     #define szfHI_IDEcriturePart   "IDEcriturePart"
     #define szfHI_LibelleOperation "LibelleOperation"
     #define szfHI_MontantOrigine   "MontantO"
     #define szfHI_CodeDevise       "Devise"
     #define szfHI_TauxChange       "Taux"
     #define szfHI_Montant          "Montant"
     #define szfHI_EstCrediteur     "EstCrediteur"     // FALSE par défaut
     #define szfHI_DateEcheance     "DateEcheance"
     #define szfHI_RAOData          "RAOData"
     #define szfHI_RAOIDLigne       "RAOIDLigne"       // Valeur calculée par une macro  MAKERAOIDECRITURE() ou MAKEPRODUCTIDECRITURE()
     #define szfHI_Flags            "Flags"            // 0x00000000 par défaut
     #define szfHI_IDImage          "IDImage"
     #define szfHI_Designation      "Designation"
     #define szfHI_CodeTVA          "CodeTVA"
     #define szfHI_TauxTVA          "TauxTVA"
     #define szfHI_DateEcheance     "DateEcheance"
     #define szfHI_ModePaiement     "ModePaiement"
     #define szfHI_Banque           "Banque"
     #define szfHI_Quantite         "Quantite"
     #define szfHI_CodeAnalytik     "CodeAnalytik"
     #define szfHI_DateEP           "DateEP"
     #define szfHI_Reviseur         "Reviseur"   // Ces 2 colonnes correspondent à la référence unique de la ligne
     #define szfHI_Reference        "Reference"  //
     #define szfHI_DateExport        "DateExport"

     static const AnsiString strfHI_DateImputation;
     static const AnsiString strfHI_AutoID;
     static const AnsiString strfHI_Compte;
     static const AnsiString strfHI_CodeJournal;
     static const AnsiString strfHI_RANDateOrigine;
     static const AnsiString strfHI_RANJnlOrigine;
     static const AnsiString strfHI_Piece;
     static const AnsiString strfHI_PieceExterne;
     static const AnsiString strfHI_NaturePiece;
     static const AnsiString strfHI_PieceLiee;
     static const AnsiString strfHI_Lettrage;
     static const AnsiString strfHI_FlagLettrage;
     static const AnsiString strfHI_IDEcriture;
     static const AnsiString strfHI_IDEcriturePart;
     static const AnsiString strfHI_LibelleOperation;
     static const AnsiString strfHI_MontantOrigine;
     static const AnsiString strfHI_CodeDevise;
     static const AnsiString strfHI_TauxChange;
     static const AnsiString strfHI_Montant;
     static const AnsiString strfHI_EstCrediteur;
     static const AnsiString strfHI_DateEcheance;
     static const AnsiString strfHI_RAOData;
     static const AnsiString strfHI_RAOIDLigne;
     static const AnsiString strfHI_Flags;
     static const AnsiString strfHI_IDImage;
     static const AnsiString strfHI_Designation;
     static const AnsiString strfHI_CodeTVA;
     static const AnsiString strfHI_TauxTVA;
     static const AnsiString strfHI_ModePaiement;
     static const AnsiString strfHI_Banque;
     static const AnsiString strfHI_Quantite;
     static const AnsiString strfHI_CodeAnalytik;
     static const AnsiString strfHI_DateEP;
     static const AnsiString strfHI_Reviseur;
     static const AnsiString strfHI_Reference;
     static const AnsiString strfHI_DateExport;

    //*****************************//
    // Définition des noms d'index //
    //*****************************//
    public:
     #define sziHI_Comptes       "idxComptes"
     #define sziHI_IDEcritures   "idxIDEcritures"
     #define sziHI_CodesJournaux "idxCodesJournaux"
     #define sziHI_RAOIDLignes   "idxRAOIDLignes"
     #define sziHI_LettrageDate  "idxLettrageDate"
     #define sziHI_PakLettrage   "idxPakLettrage"
     static const AnsiString striHI_Comptes;
     static const AnsiString striHI_IDEcritures;


    public:
     // Définition des valeurs combinées possibles du champs "Flags"
     typedef enum HIFlags {
       HIFLAGS_IMPORTEE             = 0x00000000,      // Ligne importée dans l'historique
       HIFLAGS_EST_ANNULEE          = 0x00000001,
       HIFLAGS_EST_NORMALE          = 0x00000002,
       HIFLAGS_LETTRAGE_EST_MODIFIE = 0x00000004,      // Lettrage modifié dans Rev'AO
       HIFLAGS_EST_CORRECTIVE       = 0x00000008,      // Ligne de correction - créée dans Rev'AO - d'une ligne importée (une ligne IMPORTEE+ANNULEE précède OBLIGATOIREMENT)
       HIFLAGS_A_CONTREPASSER       = 0x00000010,      // Ligne à contrepasser (obligatoirement émise par un assistant dans le journal "INVR")
       //HIFLAGS_A_NOUVEAU_DETAILLE   = 0x00000020,      // Ligne d'"A Nouveau" qui représente un détail (avec une date et un journal d'origine du détail) d'un compte "RAN détaillé" plutôt qu'un solde
       HIFLAGS_ECART_ARRONDI        = 0x00000040,      // Ligne d'écart d'arrondi d'une écriture passée dans une devise différente de la devise du dossier
       HIFLAGS_ECART_CHANGE         = 0x00000080,      // Ligne d'écart de change d'une écriture émise par Ten'Co
       HIFLAGS_VALIDEE              = 0x00000100,      // Ligne validée
       HIFLAGS_IMAGE_MODIFIEE       = 0x00000200,      // Image modifiée

       HIFLAGS_NORMALE          = HIFLAGS_EST_NORMALE, // Ligne créée normalement par une fonctionnalité de Rev'AO
//faux, ceci n'assure pas que HIFLAGS_EST_NORMALE n'est pas positionné       HIFLAGS_IMPORTEE_ANNULEE = HIFLAGS_EST_ANNULEE, // Ligne importée et annulée (via une écriture)
       HIFLAGS_NORMALE_ANNULEE  = HIFLAGS_EST_ANNULEE |
                                  HIFLAGS_EST_NORMALE, // Ligne normale annulée par une fonctionnalité de Rev'AO

       HIFLAGS_DEFAULT = HIFLAGS_IMPORTEE
     } THIFlags;

     #define LIGNE_EST_ANNULEE(x)             (x & TTableHI::HIFLAGS_EST_ANNULEE     )
     #define LIGNE_EST_IMPORTEE_ANNULEE(x)   ((x & (TTableHI::HIFLAGS_EST_ANNULEE | TTableHI::HIFLAGS_EST_NORMALE)) == TTableHI::HIFLAGS_EST_ANNULEE)
     #define LIGNE_EST_NORMALE(x)            ((x & TTableHI::HIFLAGS_NORMALE         ) == TTableHI::HIFLAGS_NORMALE         )
     #define LIGNE_EST_NORMALE_ANNULEE(x)    ((x & TTableHI::HIFLAGS_NORMALE_ANNULEE ) == TTableHI::HIFLAGS_NORMALE_ANNULEE )
     #define LIGNE_EST_IMPORTEE(x)            (!LIGNE_EST_NORMALE(x))
     #define LIGNE_EST_LETTRAGE_MODIFIE(x)    (x & TTableHI::HIFLAGS_LETTRAGE_EST_MODIFIE)
     #define LIGNE_EST_NORMALE_CORRECTIVE(x) ((x & (TTableHI::HIFLAGS_NORMALE | TTableHI::HIFLAGS_EST_CORRECTIVE)) == (TTableHI::HIFLAGS_NORMALE | TTableHI::HIFLAGS_EST_CORRECTIVE))
     #define LIGNE_EST_ECART_ARRONDI(x)      ((x & TTableHI::HIFLAGS_ECART_ARRONDI   ) == TTableHI::HIFLAGS_ECART_ARRONDI    )
     #define LIGNE_EST_ECART_CHANGE(x)       ((x & TTableHI::HIFLAGS_ECART_CHANGE    ) == TTableHI::HIFLAGS_ECART_CHANGE    )
     #define LIGNE_EST_VALIDEE(x)             (x & TTableHI::HIFLAGS_VALIDEE         )

     // Définition des valeurs ordinales possibles (short) du champ "FlagLettrage"
     enum HIFlagLettrage {
         HIFLAG_LETTRAGE_LETTRE_IMPORTE = 5,
         HIFLAG_LETTRAGE_LETTRE_IMPORTE_NP1 = 7,
         HIFLAG_LETTRAGE_LETTRE_EIC = 10,
         HIFLAG_LETTRAGE_LETTRE_NP1 = 15,
         HIFLAG_LETTRAGE_PRELETTRE = 20,
         HIFLAG_LETTRAGE_NON_LETTRE = 30,

         HIFLAG_LETTRAGE_DEFAULT = HIFLAG_LETTRAGE_NON_LETTRE,
         NB_HIFLAG_LETTRAGE = 6,                 //Nombre de FlagLettrage pour vérification par le docteur

         HIFLAG_LETTRAGE_EST_LETTRE_N = 100,
         HIFLAG_LETTRAGE_EST_LETTRE_NP1 = 101,
         HIFLAG_LETTRAGE_EST_LETTRE = 102,
         HIFLAG_LETTRAGE_EST_LETTRE_EIC = 103,
         HIFLAG_LETTRAGE_EST_LETTRE_IMPORTE = 104,
       };

     #define LIGNE_EST_LETTRE(x)              ((x == TTableHI::HIFLAG_LETTRAGE_LETTRE_EIC) || (x == TTableHI::HIFLAG_LETTRAGE_LETTRE_IMPORTE))
     #define LIGNE_EST_LETTRE_NP1(x)          ((x == TTableHI::HIFLAG_LETTRAGE_LETTRE_NP1) || (x == TTableHI::HIFLAG_LETTRAGE_LETTRE_IMPORTE_NP1))
     #define LIGNE_EST_LETTRE_EIC(x)          ((x == TTableHI::HIFLAG_LETTRAGE_LETTRE_EIC) || (x == TTableHI::HIFLAG_LETTRAGE_LETTRE_NP1))
     #define LIGNE_EST_PRELETTRE(x)           (x == TTableHI::HIFLAG_LETTRAGE_PRELETTRE)
     #define LIGNE_EST_NON_LETTRE(x)          (x == TTableHI::HIFLAG_LETTRAGE_NON_LETTRE)

     #define COULEUR_LETTRAGE_IMPORTE clBlack
     #define COULEUR_LETTRAGE         clBlue
     #define COULEUR_PRELETTRAGE      clGreen
     #define COULEUR_LETTRAGE_NP1     clOlive

    public:
     enum HIActionDelettrage                     //Types de délettrage possible
      {
        HIAD_DELETTRER_LA_LIGNE = 0,
        HIAD_DELETTRER_LE_TOUT,
        HIAD_DELETTRER_LA_LIGNE_ET_PRELETTRER_LE_RESTE,
        HIAD_PRELETTRER_LE_TOUT,

        HIAD_FIRST = HIAD_DELETTRER_LA_LIGNE,
        HIAD_LAST = HIAD_PRELETTRER_LE_TOUT
       };

     enum HIFiltreLettrage                        //Type de filtrage du lettrage
      {
        HIFL_TOUT = 0,
        HIFL_PRELETTRE_ET_NON_LETTRE,
        HIFL_TOUT_SAUF_PRELETTRAGE_EN_COURS,
        HIFL_NI_LETTRAGE_NI_PRELETTRAGE_EN_COURS,
        HIFL_QUE_PRELETTRAGE_EN_COURS,
        HIFL_LETTRAGE_IMPORTE_ET_LETTRE,
        HIFL_PRELETTRAGE_ET_LETTRE,
        HIFL_RIEN
      };

    private:
      #define STR_HIFLAG_LETTRAGE_LETTRE_IMPORTE "5"
      #if (HIFLAG_LETTRAGE_LETTRE_IMPORTE != 5)
        #pragma error *** STR_HIFLAG_LETTRAGE_LETTRE_IMPORTE a changer en fonction de HIFLAG_LETTRAGE_LETTRE_IMPORTE ***
      #endif
      #define STR_HIFLAG_LETTRAGE_LETTRE "10"
      #if (HIFLAG_LETTRAGE_LETTRE != 10)
        #pragma error *** STR_HIFLAG_LETTRAGE_LETTRE a changer en fonction de HIFLAG_LETTRAGE_LETTRE ***
      #endif
      #define STR_HIFLAG_LETTRAGE_LETTRE_NP1 "15"
      #if (HIFLAG_LETTRAGE_LETTRE_NP1 != 15)
        #pragma error *** STR_HIFLAG_LETTRAGE_LETTRE_NP1 a changer en fonction de HIFLAG_LETTRAGE_LETTRE_NP1 ***
      #endif
      #define STR_HIFLAG_LETTRAGE_PRELETTRE "20"
      #if (HIFLAG_LETTRAGE_PRELETTRE != 20)
        #pragma error *** STR_HIFLAG_LETTRAGE_PRELETTRE a changer en fonction de HIFLAG_LETTRAGE_PRELETTRE ***
      #endif
      #define STR_HIFLAG_LETTRAGE_NON_LETTRE "30"
      #if (HIFLAG_LETTRAGE_NON_LETTRE != 30)
        #pragma error *** STR_HIFLAG_LETTRAGE_NON_LETTRE a changer en fonction de HIFLAG_LETTRAGE_NON_LETTRE ***
      #endif

      #define CARACTERE_PRELETTRAGE     '#'
      #define STR_CARACTERE_PRELETTRAGE "#"
      #define STR_PREMIERE_LETTRE       "A"
      #define STR_DERNIERE_LETTRE       "ZZ"

    private:
     typedef CTable inherited;

     typedef void __fastcall ( __closure *TIncProgressBar)();

     //**************************************************************//
     // Fonctions et variables utilisées par le lettrage automatique //
     //**************************************************************//
     static AnsiString        m_strCompteALettrer;  // Numéro du compte en cours de traitement
     static int               m_nRecurs;            // Profondeur de recherche des lettrages
     static TList            *m_pSoluce;            // Liste des RecNo de la solution
     static TfrmLettrageAuto *m_frmLettrageAuto;    // Fenêtre de progression du lettrage
     bool              m_bDelLettrage;
     void       __fastcall LettrerAutoOnFilterRecord( TDataSet *pDataSet, bool &bAccept);
     bool       __fastcall ChercherLettrage( TLetAuto *pDebit, TLetAuto *pCredit, TIncProgressBar pIncFnc);
     RET_SEARCH __fastcall ChercherSomme( const TLetAuto &laValue, TLetAuto *pArray,bool &Np1);
     bool       __fastcall LettrageAutomatique();

     static CTable        *m_pTable;
     static TIntegerField *m_pfldIDMaster;
     static TIntegerField *m_pfldIDInc;
     static int m_nCountInstance;
     static int m_nReviseur;

     static int __fastcall GetReferenceSuivante( void);

    public:
      __fastcall TTableHI(TComponent* pOwner);

     static void __fastcall ( *m_fncAccepterEcriture)( const TDateTime&);

    protected:
      virtual void __fastcall InternalOpen ( void);
      virtual void __fastcall InternalClose( void);

    // Propriétés redéfinies
    __published:
     __property EICCodeTable = { stored = false}; // Initialisé via constructeur

    // Nouvelles propriétés
    // Ces propriétés s'appliquent à la ligne courante de l'historique
    public:
     __property int  AutoID             = { read = GetAutoID};
     __property bool EstCrediteur       = { read = GetEstCrediteur, write = SetEstCrediteur};
     __property bool EstUneLigneAnnulee = { read = GetEstUneLigneAnnulee};
     __property bool EstLettreEICN = { read = GetEstLettre, index = HIFLAG_LETTRAGE_LETTRE_EIC};
     __property bool EstLettreImporteN = { read = GetEstLettre, index = HIFLAG_LETTRAGE_LETTRE_IMPORTE};
     __property bool EstLettreN = { read = GetEstLettre, index = HIFLAG_LETTRAGE_EST_LETTRE_N};
     __property bool EstLettreEICNp1 = { read = GetEstLettre, index = HIFLAG_LETTRAGE_LETTRE_NP1};
     __property bool EstLettreImporteNp1 = { read = GetEstLettre, index = HIFLAG_LETTRAGE_LETTRE_IMPORTE_NP1};
     __property bool EstLettreNp1 = { read = GetEstLettre, index = HIFLAG_LETTRAGE_EST_LETTRE_NP1};
     __property bool EstLettre = { read = GetEstLettre, index = HIFLAG_LETTRAGE_EST_LETTRE};
     __property bool EstLettreEIC = { read = GetEstLettre, index = HIFLAG_LETTRAGE_EST_LETTRE_EIC};
     __property bool EstLettreImporte = { read = GetEstLettre, index = HIFLAG_LETTRAGE_EST_LETTRE_IMPORTE};
     __property bool EstPrelettre = { read = GetEstLettre, index = HIFLAG_LETTRAGE_PRELETTRE};
     __property bool EstNonLettre = { read = GetEstLettre, index = HIFLAG_LETTRAGE_NON_LETTRE};
     __property bool LettrageEstModifie = { read = GetLettrageEstModifie};
     __property bool EstLignePointee = { read = GetEstLignePointee };
     __property bool EstLigneValidee = { read = GetEstLigneValidee };

    private:
     int  __fastcall GetAutoID();                     // ID autoincrémenté de l'enregistrement courant
     bool __fastcall GetEstCrediteur();               // Le montant courant est-il créditeur ?
     void __fastcall SetEstCrediteur(bool bEstCrediteur);
     bool __fastcall GetEstUneLigneAnnulee();         // La ligne courante est-elle annulée ?
     bool __fastcall GetEstLettre(int eTypeLettrage);
     bool __fastcall GetLettrageEstModifie();
     bool __fastcall GetEstLignePointee();
     bool __fastcall GetEstLigneValidee();

     void __fastcall SetLettrageEstModifie(bool bEstModifie);

    // Les opérations suivantes ne modifient pas l'enregistrement courant de la table
    private:
     int  __fastcall CreerIDNouvelleEcriture();
     void __fastcall AnnulerEcritureSansTest( int nID, TTablePC* ptblPC, CTable *ptblHI2, int *nNewID, bool bSupprLettrage);

    // Les opérations suivantes modifient l'enregistrement courant de la table
    private:
     typedef std::list<AnsiString> TListComptes; // Liste des comptes dont les lignes ont été détruites physiquement
     void __fastcall RAZCptNonMouvementes(TTablePC* ptblPC,TListComptes& lstcptDetruits);
     void __fastcall AnnulerLigne(TTablePC* ptblPC, CTable* ptblHI2,int nIDEcrRectifiee,bool& bEtaitImportee,TListComptes& lstcptDeleted);
     void __fastcall TransfererLigne(CTable *tblHI2,int nIDEcrDst);
     class LettragesAModifier
     {
     public:
      AnsiString Compte,Lettrage;
      enum HIFlagLettrage FlagLettrage;
      __fastcall LettragesAModifier()
        {
          Compte = Lettrage = EmptyStr;
          FlagLettrage = HIFLAG_LETTRAGE_NON_LETTRE;
        }
      __fastcall ~LettragesAModifier()
        {
        }
      __fastcall LettragesAModifier(const LettragesAModifier &lam)
        {
          Compte = lam.Compte;
          Lettrage = lam.Lettrage;
          FlagLettrage = lam.FlagLettrage;
        }
     };
     typedef std::list<LettragesAModifier> TListLettragesAModifier;
     void __fastcall AjouterLigneDe(TTableHITmp*          ptblHITmp,
                                    const CPropsEcriture& cpe,
                                    TTablePC*             ptblPC,
                                    CTable*               ptblHI2,
                                    bool                  bEstCorrective,
                                    int                   nReviseur = 0,
                                    int                   nRef = 0,
                                    TListLettragesAModifier *lLettragesAModifier = NULL);
     void __fastcall AjouterEcartArrondi(const CPropsEcriture& cpe,
                                         TTablePC*             ptblPC,
                                         CTable               *ptblHI2,
                                         const Currency&       curEcartArr);
     void __fastcall AjouterEcartsChange( const CPropsEcriture    &cpe,
                                          TTablePC                *ptblPC,
                                          CTable                  *ptblHI2,
                                          const TEcartChgEcriture *pEcartCh);
     void __fastcall RectifierEcriture(int                   nIDEcrOrigine,
                                       const CPropsEcriture& cpeRectifiee,
                                       TTableHITmp*          ptblHITmp,
                                       TTablePC*             ptblPC,
                                       CTable*               ptblHI2,
                                       CBarre*               pbarre);
     void __fastcall SupprimerAncienLettrageNp1(TTablePC *tblPC,const TDateTime &DateFinExNp1,CBarre *Barre);
     void __fastcall AjouterListeLettrage(TList *ListeAutoID,const AnsiString &Lettrage,bool LettrageNp1) const;
     void __fastcall LettrerListeLettrage();
     void        __fastcall LettrerPrelettrageEquilibreQuick(const AnsiString &strLettre,const TList *pListeRecNo);
     bool __fastcall LettrageCombinatoire(unsigned int Profondeur);
     bool __fastcall LettrageCombinatoire(unsigned int Profondeur,unsigned int ProfondeurMax,AnsiString &Lettrage);
    public:
     bool __fastcall EstJnlMouvemente(const AnsiString& strCodeJnl);
     void __fastcall Cloturer(const TDateTime &dateFinExN,
                              const TDateTime &dateFinExNp1,
                              const AnsiString &strJnlANouveau,
                              const AnsiString &CompteResultatPerte,
                              const AnsiString &CompteResultatBenefice,
                              TTableHI *ptblHINp1,
                              TTablePC *ptblPC,
                              TTable *tblNotes,
                              TTableHI *tblINVR,
                              CTable   *ptblHI2,
                              CTable   *tblHI2Np1,
                              bool ANEnDetail,
                              CBarre *pBarre);
     void __fastcall RecalculerSoldeN(TTablePC *tblPC,const TDateTime &AncienneDateFinEx,const TDateTime &NouvelleDateFinEx);
     Currency    __fastcall ObtenirSolde();
     bool        __fastcall AnnulerEcriture(int nID, TTablePC* TablePC, CTable *ptblHI2, int *nNewID = NULL, bool bSupprLettrage = true);
     Currency    __fastcall ResultatSituation(const TDateTime &DateSituation,bool AvecBarre = true);
     void        __fastcall Lettrer(const AnsiString &Lettre,bool Np1);
     void        __fastcall LettrerAutomatique(const AnsiString &strCompte, TYPE_LETTRAGE *tLettrage, int *Recurs, CTable *ptblHI2);
     void        __fastcall Prelettrer(const AnsiString &Lettre);
     void        __fastcall Delettrer(enum HIActionDelettrage eActionDelettrage = HIAD_DELETTRER_LA_LIGNE);
     void        __fastcall LettrerPrelettrageEquilibre(const AnsiString &strCompte,const AnsiString &Prelettre,const AnsiString &Lettre,bool bCreateFilter=true);
     AnsiString  __fastcall LettrageSuivant(const AnsiString &strCompte);
     AnsiString  __fastcall PrelettrageSuivant(const AnsiString &strCompte);
     bool __fastcall ReclasserLettrages(const AnsiString &ComptesAReclasser = EmptyStr,CBarre *Barre = NULL);
     static void __fastcall IncLettre(AnsiString &strLettre);
     static void __fastcall DrawLettrage(TDBGrid *Sender,const TRect &Rect,int DataCol,TColumn* Column,TGridDrawState State,enum HIFlagLettrage FlagLettrage);
     void        __fastcall FiltrerLettrage(enum HIFiltreLettrage TypeFiltre,const AnsiString &Lettre = EmptyStr);
     void        __fastcall FiltrerLettrage(const AnsiString &Compte,const AnsiString &Lettre,enum HIFlagLettrage TypeLettrage);
     bool        __fastcall LettrageTotalementDans( const TDateTime &DateDeb, const TDateTime &DateFin, const AnsiString &Compte, const AnsiString &Lettre, enum HIFlagLettrage TypeLettrage);
     void        __fastcall ChangeIDEcriture( int nCurID, int nNewID);
     bool __fastcall TransfererCompte(TTableHITmp *tblHITmp,TTablePC *tblPC,CTable *tblHI2,const AnsiString &Compte1,const AnsiString &Compte2,bool TransfererTout,TList *pListeAutoIdTransferes,const TDateTime &dtDateFinTransfert = 0, bool bEntreprise = false);
     void        __fastcall FiltrerLettrageRange(const AnsiString &Compte,const AnsiString &Lettre,enum HIFlagLettrage TypeLettrage);
     TTableHI* __fastcall CreerTableLettrage(TStringField **fCompte,TIntegerField **fFlagLettrage,TStringField **fLettrage,TDateTimeField **fDateImputation);
     bool        __fastcall EstEcriturePointee( int nIDEcr);
     bool        __fastcall EstEcritureValidee( int nIDEcr);
     void        __fastcall ValidationEcriture( int nIDEcr);
     void        __fastcall GenerateReferences( void);

     static void __fastcall SetCodeReviseur( int nCode);
   }; /* class TTableHI */



   //****************//
   // CPropsEcriture //
   //****************//
   class PACKAGE_COMPTA CPropsEcriture : public TObject
   {
    private:
     int                m_nIDEcriture;    // ID de l'écriture
     TTableHI::THIFlags m_eFlags;
     const CDevise&     m_devEcriture;    // Devise de l'écriture
     TCodeDev           m_eCodeDevise;    // Code de la devise
     bool               m_bDeviseEuroNat; // TRUE si la devise est la devise nationale (qui disparaîtra en 2002) d'une nation Européenne
     double             m_dblTxChgDevise; // Taux de change de la devise (ignoré pour une devise Euro)
     const AnsiString&  m_strCodeJnl;
     const TDateTime&   m_dateImputation;
     unsigned int       m_eRAOIDLigne;    // ID du module ou du produit qui a généré la ligne
     bool               m_bPieceConst;    // TRUE si la pièce est constante sur l'écriture
     const AnsiString&  m_strPieceConst;  // Pièce constante de l'écriture (ignorée si !m_bPieceConst)
     const AnsiString&  m_strNaturePiece;
     const AnsiString &m_IDEcriturePart;
    public:
     __property int                IDEcriture        = { read = m_nIDEcriture};
     __property TTableHI::THIFlags Flags             = { read = m_eFlags};
     __property const CDevise&     Devise            = { read = m_devEcriture};
     __property TCodeDev           CodeDevise        = { read = m_eCodeDevise};
     __property bool               EstDeviseEuroNat  = { read = m_bDeviseEuroNat};
     __property double             TauxChangeDevise  = { read = m_dblTxChgDevise};
     __property const AnsiString&  CodeJournal       = { read = m_strCodeJnl};
     __property const TDateTime&   DateImputation    = { read = m_dateImputation};
     __property bool               EstPieceConstante = { read = m_bPieceConst};
     __property const AnsiString&  PieceConstante    = { read = m_strPieceConst};
     __property const AnsiString&  NaturePiece       = { read = m_strNaturePiece};
     __property unsigned int       RAOIDLigne        = { read = m_eRAOIDLigne};
     __property const AnsiString &IDEcriturePart = {read = m_IDEcriturePart};


    public:
     friend TTableHI& __fastcall operator<<(TTableHI& tblHI, const CPropsEcriture& pe);
     friend CTable&   __fastcall operator<<(CTable& tblHI2, const CPropsEcriture& pe);
     void __fastcall InitHIPieceFrom(TTableHI* ptblHI, TTableHITmp* ptblHITmp) const;
     __fastcall CPropsEcriture(int                nIDEcriture,
                                TTableHI::THIFlags eFlags,
                                const CDevise&     devEcriture,
                                const AnsiString&  strCodeJnl,
                                const TDateTime&   dateImputation,
                                bool               bPieceConst,
                                const AnsiString&  strPieceConst,
                                const AnsiString&  strNaturePiece,
                                unsigned int       eRAOIDLigne,
                                const AnsiString &strIDEcriturePart);
   }; /* class CPropsEcriture */


   //*************//
   // TTableHITmp //
   //*************//
   class PACKAGE_COMPTA TTableHITmp : public CTable
   {
    friend class TTableHI;
    public:
     #define szfHITmp_Compte           "Compte"
     #define szfHITmp_LibelleOperation "LibelleOperation"
     #define szfHITmp_Piece            "Piece"
     #define szfHITmp_PieceExterne     "PieceExterne"
     #define szfHITmp_Debit            "Debit"
     #define szfHITmp_Credit           "Credit"
     #define szfHITmp_IDLigne          "IDLigne"
     #define szfHITmp_Lettrage         "Lettrage"
     #define szfHITmp_FlagLettrage     "FlagLettrage"
     #define szfHITmp_RAOData          "RAOData"
     #define szfHITmp_RAOIDLigne       "RAOIDLigne"
     #define szfHITmp_EstNouvelleLigne "EstNouvelleLigne" // TRUE par défaut
     #define szfHITmp_Designation      "Designation"
     #define szfHITmp_CodeTVA          "CodeTVA"
     #define szfHITmp_TauxTVA          "TauxTVA"
     #define szfHITmp_DateEcheance     "DateEcheance"
     #define szfHITmp_ModePaiement     "ModePaiement"
     #define szfHITmp_Banque           "Banque"
     #define szfHITmp_Quantite         "Quantite"
     #define szfHITmp_CodeAnalytik     "CodeAnalytik"
     #define szfHITmp_DateEP           "DateEP"
     #define szfHITmp_IDImage          "IDImage"
     #define szfHITmp_IDImageModifie   "IDImageModifie"

     static const AnsiString strfHITmp_Compte;
     static const AnsiString strfHITmp_LibelleOperation;
     static const AnsiString strfHITmp_Piece;
     static const AnsiString strfHITmp_PieceExterne;
     static const AnsiString strfHITmp_Debit;
     static const AnsiString strfHITmp_Credit;
     static const AnsiString strfHITmp_IDLigne;
     static const AnsiString strfHITmp_Lettrage;
     static const AnsiString strfHITmp_FlagLettrage;
     static const AnsiString strfHITmp_RAOData;
     static const AnsiString strfHITmp_RAOIDLigne;
     static const AnsiString strfHITmp_EstNouvelleLigne;
     static const AnsiString strfHITmp_Designation;
     static const AnsiString strfHITmp_CodeTVA;
     static const AnsiString strfHITmp_TauxTVA;
     static const AnsiString strfHITmp_DateEcheance;
     static const AnsiString strfHITmp_ModePaiement;
     static const AnsiString strfHITmp_Banque;
     static const AnsiString strfHITmp_Quantite;
     static const AnsiString strfHITmp_CodeAnalytik;
     static const AnsiString strfHITmp_DateEP;
     static const AnsiString strfHITmp_IDImage;
     static const AnsiString strfHITmp_IDImageModifie;

    // Propriétés redéfinies
    __published:
     __property EICTypeTable = { default = ttTmp, stored = false}; // Initialisé via constructeur
     __property Exclusive    = { default = true,  stored = false}; // Initialisé via constructeur
     __property TableName    = {                  stored = false}; // Initialisé via constructeur

    private:
     // Les opérations suivantes ne modifient pas la ligne courante
     bool __fastcall ContientLaLigneDOrigine(int nIDLigneOrigine, bool& bEstLaLigneCourante);

    public:
     // Les opérations suivantes modifient la ligne courante
     bool __fastcall CopyEcritureFrom( int                nIDEcriture,    // ID de l'écriture à recopier
                                       TTableHI*          ptblHISrc,      // HI dans lequel prendre l'écriture
                                       CTable*            ptblHI2,        // HI dans lequel prendre l'écriture
                                       CDevise&           devEcriture,    // Retourne la devise de l'écriture
                                       TDateTime&         dateImputation, //    "     la date d'imputation de l'écriture
                                       AnsiString&        strCodeJnl,     //    "     le code journal de l'écriture
                                       bool&              bPieceConst,    //    "     TRUE si la pièce de l'écriture est constante sur toutes ses lignes
                                       AnsiString&        strPieceConst,  //    "     la pièce constante de l'écriture (à ignorer si bPieceConstante == false)
                                       AnsiString&        strNaturePiece, //    "     la nature de la pièce de l'écriture
                                       bool&              bAnnulee,       //    "     TRUE si l'écriture ne contient que des lignes annulées
                                       TEcartChgEcriture *pEcartCh,       //    "     les lignes d'écart de change sauf si pointeur NULL
                                       AnsiString &IDEcriturePart,
                                       CBarre*            pbarre); /* TRUE si écriture modifiable i.e. non annulée */

     void __fastcall ValideEcriture( int                      nID,             // IdEcritureNouvelle pour nouvelle
                                     unsigned int             eIDRAO,          // Valeur MAKERAOIDECRITURE() ou MAKEPRODUCTIDECRITURE()
                                     TTableHI::THIFlags       eHIFlagEcriture, // TTableHI::HIFLAGS_IMPORTEE/NORMALE
                                     const CDevise&           devEcriture,     // Devise de l'écriture
                                     const TDateTime&         dtImputation,
                                     const AnsiString&        strCodeJournal,
                                     bool                     bPieceConst,     // TRUE si la pièce de l'écriture est constante sur toutes ses lignes
                                     const AnsiString&        strPieceConst,   // Pièce constante de l'écriture (ignorée si bPieceConstante == false)
                                     const AnsiString&        strNaturePiece,  // "" (ou EmptyStr) pour aucune
                                     const TEcartChgEcriture *pEcartCh,
                                     TTableHI*                TableHI,
                                     CTable*                  ptblHI2Dst,
                                     TTablePC*                TablePC,
                                     const AnsiString &IDEcriturePart,
                                     CBarre*                  pbarre, /* = NULL */
                                     int*                     pnIDEcrValidee = NULL /* Retourne le n° de l'écriture validée */);
      static void __fastcall VerifierINV(const AnsiString &Journal,const TDateTime &DateImputation);
    private:
     typedef CTable inherited;
    public:
     __fastcall TTableHITmp(TComponent* pOwner);
   }; /* class TTableHITmp */



   //**********//
   // TTablePT //
   //**********///////////////////////////////////////////////////////////////
   //                                                                       //
   //    Cette classe encapsule les traitements relatifs aux consignes du   //
   //    programmes de travail.                                             //
   ///////////////////////////////////////////////////////////////////////////
   class PACKAGE_COMPTA TTablePT : public CTable
   {
    friend TTablePC;
    public:
     #define szfPT_Racine        "Racine"
     #define szfPT_Ordre         "Ordre"
     #define szfPT_TypeCondition "TypeCondition"           // cf <<enum PT_TypeCondition>>
     #define szfPT_Consigne      "Consigne"
     #define szfPT_Visa          "Visa"
     static const AnsiString strfPT_Racine;
     static const AnsiString strfPT_Ordre;
     static const AnsiString strfPT_TypeCondition;
     static const AnsiString strfPT_Consigne;
     static const AnsiString strfPT_Visa;
    public:
     // Valeurs possibles du champ "TypeCondition"
     enum PTTypeCondition
      {
        PTTYPECONDITION_INCONDITIONNEL_COMMUN = 0,  //L'enregistrement représente une consigne commune obligatoire
/*Non utilisé*/PTTYPECONDITION_CONDITIONNEL_COMMUN,        //L'enregistrement représente une consigne commune conditionnelle à la présence de compte
        PTTYPECONDITION_DOSSIER,                    //L'enregistrement représente une consigne du dossier
        PTTYPECONDITION_ANCIEN_COMMUN               //L'enregistrement représente une ancienne consigne (juste le temps de la MAJ)
      };

    private:
     typedef CTable inherited;
    public:
     __fastcall TTablePT(TComponent* pOwner);


    // Propriétés redéfinies
    __published:
     __property EICCodeTable = { stored = false}; // Initialisé via constructeur

    // Nouvelles propriétés
    private:
     bool       __fastcall GetEstVise();        // true si le programme de travail est visé
     AnsiString __fastcall GetMemo();
     void       __fastcall SetMemo(AnsiString& Texte);
     int        __fastcall OrdreSuivant(PTTypeCondition TypeCond);

    public:
     __property bool       EstVise  = { read = GetEstVise};
     __property AnsiString Resultat = { read = GetMemo,    write = SetMemo};

    // Les opérations suivantes modifient l'enregistrement courant de la table
    protected:
     bool __fastcall SupprimerAncienPTCommun(CBarre *Barre = 0);
     bool __fastcall RestaurerAncienVisaPTCommun(CBarre *Barre = 0);
    public:
     bool __fastcall CreerConsigne(const AnsiString &Racine,const AnsiString &Consigne,PTTypeCondition TypeCondition = PTTYPECONDITION_DOSSIER);
     bool __fastcall EstToutVise(const AnsiString &Racine,bool *RacineVide = NULL);
     void __fastcall SupprimerConsignes(AnsiString & Racine);
     void __fastcall SupprimerConsigne();
    private:
     void __fastcall fmFiltrerComptesMouvementes(TDataSet *DataSet, bool &Accept);

    // Les opérations suivantes ne modifient pas l'enregistrement courant de la table
    public:
     void __fastcall ViserConsigne(bool bViser);
     void __fastcall ViserRacine(const AnsiString &Racine,bool bViser);
     bool __fastcall MonterConsigne();
     bool __fastcall DescendreConsigne();
    private:
     bool __fastcall ComptesMouvementes(TTablePC * Table_PC);


    //************************//
    // Opérations de filtrage //
    //************************//
    public:
     void __fastcall FiltrerRacine(const AnsiString& Racine);
     void __fastcall FiltrerComptesMouvementes(TTablePC * Table_PC);
   }; /* class TTablePT */

   class PACKAGE_COMPTA CLigneEcriture
   {
     private:
       AnsiString               m_strCompte;
       TDateTime                m_dateRANOrigine;
       AnsiString               m_strRANJournalOrigine;
       AnsiString               m_strPiece;
       AnsiString               m_strLettrage;
       TTableHI::HIFlagLettrage m_nFlagLettrage;
       AnsiString               m_strLibelleOperation;
       Currency                 m_curMontantOrgine;
       TCodeDev                 m_codeDevise;
       double                   m_dTaux;
       bool                     m_bEstCrediteur;
       int                      m_nFlags;
       AnsiString               m_strIDEcriturePart;
       AnsiString               m_strRAOData;
       int                      m_nIDImage;
       AnsiString               m_strDesignation;
       TDateTime                m_dtDateEcheance;
       double                   m_dQuantite;
       AnsiString               m_strBanquePaiement;
       MODE_PAIEMENT            m_eModePaiement;
       double                   m_dTauxTVA;
       AnsiString               m_strCodeTVA;
       AnsiString               m_strNaturePiece;
       AnsiString               m_strPieceExt;
       AnsiString               m_strAnalyt;
       TDateTime                m_dtRapprochement;
       int                      m_nReviseur;
       int                      m_nReference;

       void __fastcall Init( const AnsiString &strCompte, const AnsiString &strLibelleOp, bool bEstCrediteur, const Currency &curMontantOrigine, TCodeDev eCodeDevise, double dTaux, const AnsiString &strPiece, const AnsiString &strNaturePiece, const AnsiString &strPieceExt);

     public:
       __fastcall CLigneEcriture( const AnsiString &strCompte, const AnsiString &strLibelleOp, bool bEstCrediteur, const Currency &curMontantOrigine, const AnsiString &strPiece = EmptyStr, const AnsiString &strNaturePiece = EmptyStr, const AnsiString &strPieceExt = EmptyStr);
       __fastcall CLigneEcriture( const AnsiString &strCompte, const AnsiString &strLibelleOp, bool bEstCrediteur, const Currency &curMontantOrigine, TCodeDev eCodeDevise, double dTaux, const AnsiString &strPiece = EmptyStr, const AnsiString &strNaturePiece = EmptyStr, const AnsiString &strPieceExt = EmptyStr);

       __property AnsiString               Compte            = { read=m_strCompte           , write=m_strCompte            };
       __property TDateTime                RANDateOrigine    = { read=m_dateRANOrigine      , write=m_dateRANOrigine       };
       __property AnsiString               RANJournalOrigine = { read=m_strRANJournalOrigine, write=m_strRANJournalOrigine };
       __property AnsiString               Piece             = { read=m_strPiece            , write=m_strPiece             };
       __property AnsiString               Lettrage          = { read=m_strLettrage         , write=m_strLettrage          };
       __property TTableHI::HIFlagLettrage FlagLettrage      = { read=m_nFlagLettrage       , write=m_nFlagLettrage        };
       __property AnsiString               LibelleOperation  = { read=m_strLibelleOperation , write=m_strLibelleOperation  };
       __property Currency                 MontantOrigine    = { read=m_curMontantOrgine    , write=m_curMontantOrgine     };
       __property TCodeDev                 CodeDevise        = { read=m_codeDevise          , write=m_codeDevise           };
       __property double                   Taux              = { read=m_dTaux               , write=m_dTaux                };
       __property bool                     EstCrediteur      = { read=m_bEstCrediteur       , write=m_bEstCrediteur        };
       __property int                      Flags             = { read=m_nFlags              , write=m_nFlags               };
       __property AnsiString               IDEcriturePart    = { read=m_strIDEcriturePart   , write=m_strIDEcriturePart    };
       __property AnsiString               RAOData           = { read=m_strRAOData          , write=m_strRAOData           };
       __property int                      IDImage           = { read=m_nIDImage            , write=m_nIDImage             };
       __property AnsiString               Designation       = { read=m_strDesignation      , write=m_strDesignation       };
       __property TDateTime                DateEcheance      = { read=m_dtDateEcheance      , write=m_dtDateEcheance       };
       __property double                   Quantite          = { read=m_dQuantite           , write=m_dQuantite            };
       __property AnsiString               BanquePaiement    = { read=m_strBanquePaiement   , write=m_strBanquePaiement    };
       __property MODE_PAIEMENT            ModePaiement      = { read=m_eModePaiement       , write=m_eModePaiement        };
       __property double                   TauxTVA           = { read=m_dTauxTVA            , write=m_dTauxTVA             };
       __property AnsiString               CodeTVA           = { read=m_strCodeTVA          , write=m_strCodeTVA           };
       __property AnsiString               NaturePiece       = { read=m_strNaturePiece      , write=m_strNaturePiece       };
       __property AnsiString               PieceExterne      = { read=m_strPieceExt         , write=m_strPieceExt          };
       __property AnsiString               CodeAnalytique    = { read=m_strAnalyt           , write=m_strAnalyt            };
       __property TDateTime                DateRapprochement = { read=m_dtRapprochement     , write=m_dtRapprochement      };
       __property int                      Reviseur          = { read=m_nReviseur           , write=m_nReviseur            };
       __property int                      Reference         = { read=m_nReference          , write=m_nReference           };
   };


   class PACKAGE_COMPTA CLignesEcriture
   {
     private:
       TList *m_pEcr;
       int __fastcall GetCount() const;
       CLigneEcriture *GetLigneEcriture( int nIndex) const;

     public:
       __fastcall  CLignesEcriture();
       virtual __fastcall ~CLignesEcriture();

       int  __fastcall Add( const AnsiString &strCompte, const AnsiString &strLibelleOp, bool bEstCrediteur, const Currency &curMontantOrigine, const AnsiString &strPiece = EmptyStr, const AnsiString &strNaturePiece = EmptyStr, const AnsiString &strPieceExt = EmptyStr);
       int  __fastcall Add( const AnsiString &strCompte, const AnsiString &strLibelleOp, bool bEstCrediteur, const Currency &curMontantOrigine, TCodeDev eCodeDevise, double dTaux, const AnsiString &strPiece = EmptyStr, const AnsiString &strNaturePiece = EmptyStr, const AnsiString &strPieceExt = EmptyStr);
       void __fastcall Clear();
       void __fastcall Delete( int nIndex);

       __property int Count = { read=GetCount };
       __property CLigneEcriture *Ligne[int nIndex] = { read=GetLigneEcriture };
   };


   class PACKAGE_COMPTA CEcriture
   {
     private:
       // Liste des valeurs communes à l'écriture
       TDateTime        m_dateImputation;
       AnsiString       m_strCodeJournal;
       TCodeDev         m_codeDevise;
       double           m_dTaux;
       int              m_nRAOIDLigne;
       bool             m_bDeviseConstante;
       MODE_PAIEMENT    m_eNaturePiece;
       int              m_nIDEcriture;
       CLignesEcriture *m_pLignesEcr;
       CLignesEcriture *m_pEcartsChange;

       void __fastcall Init( const TDateTime &dateImputation, const AnsiString &strCodeJnl, TCodeDev eCodeDevise, double dTaux, int nRAOIDLigne, MODE_PAIEMENT eNaturePiece, bool bDeviseConst/*,const AnsiString &strIDEcriturePart*/);
       void __fastcall AjouterLigneHI( TTableHI *ptblHI, const AnsiString &strCompte,
                                     const AnsiString &strPiece,
                                     const AnsiString &strLettrage, TTableHI::HIFlagLettrage eFlagLettrage,
                                     const AnsiString &strLibelleOp, const Currency &curMontantOrigine, TCodeDev eCodeDevise,
                                     double dTauxChange, bool bEstCrediteur, int nFlags,
                                     int nIDImage,
                                     const TDateTime &dtDateEcheance,
                                     MODE_PAIEMENT eModePaiement,
                                     const TDateTime &dtRappr, int nCodeReviseur, int nRef);
       void __fastcall AjouterLigneHI2(CTable *ptblHI2, const TDateTime &dateRANOrigine,
                                     const AnsiString &strRANJnlOrigine,
                                     const AnsiString &strIDEcriturePart,
                                     const AnsiString &strRAOData, const AnsiString &strDesignation,
                                     double dQuantite, const AnsiString &strBanquePaiement,
                                     double dTauxTVA, const AnsiString &strCodeTVA,
                                     const AnsiString &strNaturePiece, const AnsiString &strPieceExt, const AnsiString &strCodeAnalytik);
       bool __fastcall GetEstEcritureImportee() const;
       bool __fastcall GetEstEcritureImporteeModifiee() const;

     public:
       __fastcall  CEcriture( const TDateTime &dateImputation, const AnsiString &strCodeJnl, MODE_PAIEMENT eNaturePiece = MP_AUCUN, int nRAOIDLigne = -1);
       __fastcall  CEcriture( TCodeDev eCodeDevise, double dTaux, const TDateTime &dateImputation, const AnsiString &strCodeJnl, MODE_PAIEMENT eNaturePiece = MP_AUCUN, int nRAOIDLigne = -1);
       __fastcall  CEcriture( CTable *ptbl,CTable *ptbl2, int nIdEcr);
       virtual __fastcall ~CEcriture();

       void __fastcall ForceEcritureNouvelle();
       void __fastcall TransformerEcritureImporteeEnNormale();
       void __fastcall ValideEcriture( TTableHI *ptblHI, TTablePC *ptblPC,CTable *ptblHI2, bool bMove, CBarre *pBarre /*= NULL*/);

       __property TCodeDev         CodeDevise      = { read=m_codeDevise     };
       __property AnsiString       CodeJournal     = { read=m_strCodeJournal };
       __property TDateTime        DateImputation  = { read=m_dateImputation };
       __property int              IDEcriture      = { read=m_nIDEcriture    };
       __property MODE_PAIEMENT    NaturePiece     = { read=m_eNaturePiece   };
       __property int              RAOIDLigne      = { read=m_nRAOIDLigne    };
       __property double           Taux            = { read=m_dTaux          };
       __property CLignesEcriture *LignesEcriture  = { read=m_pLignesEcr     };
       __property CLignesEcriture *EcartsChange    = { read=m_pEcartsChange  };

       __property bool EstEcritureImportee         = { read=GetEstEcritureImportee         };
       __property bool EstEcritureImporteeModifiee = { read=GetEstEcritureImporteeModifiee };
   };


   // (1) : les valeur par def sont initialisées directement dans la table
  } /* namespace Compta */
  #ifndef NO_IMPLICIT_NAMESPACE_USE
   using namespace Compta;
  #endif

 #endif /* #ifndef __BCPLUSPLUS__ #else */

#endif /* #ifndef _AUTONOME */
 #endif /* #ifndef _COMPTA_H */
